dotfiles/config/ags/quickactions/@girs/modemmanager-1.0.d.ts

/// <reference path="./gio-2.0.d.ts" />
/// <reference path="./gobject-2.0.d.ts" />
/// <reference path="./glib-2.0.d.ts" />
/// <reference path="./gmodule-2.0.d.ts" />

/**
 * Type Definitions for Gjs (https://gjs.guide/)
 *
 * These type definitions are automatically generated, do not edit them by hand.
 * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
 *
 * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
 */

declare module 'gi://ModemManager?version=1.0' {
    // Module dependencies
    import type Gio from 'gi://Gio?version=2.0';
    import type GObject from 'gi://GObject?version=2.0';
    import type GLib from 'gi://GLib?version=2.0';
    import type GModule from 'gi://GModule?version=2.0';

    export namespace ModemManager {
        /**
         * ModemManager-1.0
         */

        export namespace BearerAccessTypePreference {
            export const $gtype: GObject.GType<BearerAccessTypePreference>;
        }

        enum BearerAccessTypePreference {
            NONE,
            '3GPP_ONLY',
            '3GPP_PREFERRED',
            NON_3GPP_ONLY,
        }

        export namespace BearerIpMethod {
            export const $gtype: GObject.GType<BearerIpMethod>;
        }

        enum BearerIpMethod {
            UNKNOWN,
            PPP,
            STATIC,
            DHCP,
        }

        export namespace BearerMultiplexSupport {
            export const $gtype: GObject.GType<BearerMultiplexSupport>;
        }

        enum BearerMultiplexSupport {
            UNKNOWN,
            NONE,
            REQUESTED,
            REQUIRED,
        }

        export namespace BearerProfileSource {
            export const $gtype: GObject.GType<BearerProfileSource>;
        }

        enum BearerProfileSource {
            UNKNOWN,
            ADMIN,
            USER,
            OPERATOR,
            MODEM,
            DEVICE,
        }

        export namespace BearerType {
            export const $gtype: GObject.GType<BearerType>;
        }

        enum BearerType {
            UNKNOWN,
            DEFAULT,
            DEFAULT_ATTACH,
            DEDICATED,
        }

        export namespace CallDirection {
            export const $gtype: GObject.GType<CallDirection>;
        }

        enum CallDirection {
            UNKNOWN,
            INCOMING,
            OUTGOING,
        }

        export namespace CallState {
            export const $gtype: GObject.GType<CallState>;
        }

        enum CallState {
            UNKNOWN,
            DIALING,
            RINGING_OUT,
            RINGING_IN,
            ACTIVE,
            HELD,
            WAITING,
            TERMINATED,
        }

        export namespace CallStateReason {
            export const $gtype: GObject.GType<CallStateReason>;
        }

        enum CallStateReason {
            UNKNOWN,
            OUTGOING_STARTED,
            INCOMING_NEW,
            ACCEPTED,
            TERMINATED,
            REFUSED_OR_BUSY,
            ERROR,
            AUDIO_SETUP_FAILED,
            TRANSFERRED,
            DEFLECTED,
        }
        class CdmaActivationError extends GLib.Error {
            static $gtype: GObject.GType<CdmaActivationError>;

            // Static fields

            static NONE: number;
            static UNKNOWN: number;
            static ROAMING: number;
            static WRONGRADIOINTERFACE: number;
            static COULDNOTCONNECT: number;
            static SECURITYAUTHENTICATIONFAILED: number;
            static PROVISIONINGFAILED: number;
            static NOSIGNAL: number;
            static TIMEDOUT: number;
            static STARTFAILED: number;

            // Constructors

            constructor(options: { message: string; code: number });
            _init(...args: any[]): void;

            // Static methods

            static quark(): GLib.Quark;
        }

        export namespace CellType {
            export const $gtype: GObject.GType<CellType>;
        }

        enum CellType {
            UNKNOWN,
            CDMA,
            GSM,
            UMTS,
            TDSCDMA,
            LTE,
            '5GNR',
        }
        class ConnectionError extends GLib.Error {
            static $gtype: GObject.GType<ConnectionError>;

            // Static fields

            static UNKNOWN: number;
            static NOCARRIER: number;
            static NODIALTONE: number;
            static BUSY: number;
            static NOANSWER: number;

            // Constructors

            constructor(options: { message: string; code: number });
            _init(...args: any[]): void;

            // Static methods

            static quark(): GLib.Quark;
        }

        class CoreError extends GLib.Error {
            static $gtype: GObject.GType<CoreError>;

            // Static fields

            static FAILED: number;
            static CANCELLED: number;
            static ABORTED: number;
            static UNSUPPORTED: number;
            static NOPLUGINS: number;
            static UNAUTHORIZED: number;
            static INVALIDARGS: number;
            static INPROGRESS: number;
            static WRONGSTATE: number;
            static CONNECTED: number;
            static TOOMANY: number;
            static NOTFOUND: number;
            static RETRY: number;
            static EXISTS: number;
            static WRONGSIMSTATE: number;
            static RESETRETRY: number;

            // Constructors

            constructor(options: { message: string; code: number });
            _init(...args: any[]): void;

            // Static methods

            static quark(): GLib.Quark;
        }

        export namespace FirmwareImageType {
            export const $gtype: GObject.GType<FirmwareImageType>;
        }

        enum FirmwareImageType {
            UNKNOWN,
            GENERIC,
            GOBI,
        }
        class MessageError extends GLib.Error {
            static $gtype: GObject.GType<MessageError>;

            // Static fields

            static MEFAILURE: number;
            static SMSSERVICERESERVED: number;
            static NOTALLOWED: number;
            static NOTSUPPORTED: number;
            static INVALIDPDUPARAMETER: number;
            static INVALIDTEXTPARAMETER: number;
            static SIMNOTINSERTED: number;
            static SIMPIN: number;
            static PHSIMPIN: number;
            static SIMFAILURE: number;
            static SIMBUSY: number;
            static SIMWRONG: number;
            static SIMPUK: number;
            static SIMPIN2: number;
            static SIMPUK2: number;
            static MEMORYFAILURE: number;
            static INVALIDINDEX: number;
            static MEMORYFULL: number;
            static SMSCADDRESSUNKNOWN: number;
            static NONETWORK: number;
            static NETWORKTIMEOUT: number;
            static NOCNMAACKEXPECTED: number;
            static UNKNOWN: number;

            // Constructors

            constructor(options: { message: string; code: number });
            _init(...args: any[]): void;

            // Static methods

            static quark(): GLib.Quark;
        }

        class MobileEquipmentError extends GLib.Error {
            static $gtype: GObject.GType<MobileEquipmentError>;

            // Static fields

            static PHONEFAILURE: number;
            static NOCONNECTION: number;
            static LINKRESERVED: number;
            static NOTALLOWED: number;
            static NOTSUPPORTED: number;
            static PHSIMPIN: number;
            static PHFSIMPIN: number;
            static PHFSIMPUK: number;
            static SIMNOTINSERTED: number;
            static SIMPIN: number;
            static SIMPUK: number;
            static SIMFAILURE: number;
            static SIMBUSY: number;
            static SIMWRONG: number;
            static INCORRECTPASSWORD: number;
            static SIMPIN2: number;
            static SIMPUK2: number;
            static MEMORYFULL: number;
            static INVALIDINDEX: number;
            static NOTFOUND: number;
            static MEMORYFAILURE: number;
            static TEXTTOOLONG: number;
            static INVALIDCHARS: number;
            static DIALSTRINGTOOLONG: number;
            static DIALSTRINGINVALID: number;
            static NONETWORK: number;
            static NETWORKTIMEOUT: number;
            static NETWORKNOTALLOWED: number;
            static NETWORKPIN: number;
            static NETWORKPUK: number;
            static NETWORKSUBSETPIN: number;
            static NETWORKSUBSETPUK: number;
            static SERVICEPIN: number;
            static SERVICEPUK: number;
            static CORPPIN: number;
            static CORPPUK: number;
            static HIDDENKEYREQUIRED: number;
            static EAPMETHODNOTSUPPORTED: number;
            static INCORRECTPARAMETERS: number;
            static COMMANDDISABLED: number;
            static COMMANDABORTED: number;
            static NOTATTACHEDRESTRICTED: number;
            static NOTALLOWEDEMERGENCYONLY: number;
            static NOTALLOWEDRESTRICTED: number;
            static FIXEDDIALNUMBERONLY: number;
            static TEMPORARILYOUTOFSERVICE: number;
            static LANGUAGEORALPHABETNOTSUPPORTED: number;
            static UNEXPECTEDDATAVALUE: number;
            static SYSTEMFAILURE: number;
            static DATAMISSING: number;
            static CALLBARRED: number;
            static MESSAGEWAITINGINDICATIONSUBSCRIPTIONFAILURE: number;
            static UNKNOWN: number;
            static IMSIUNKNOWNINHSS: number;
            static ILLEGALUE: number;
            static IMSIUNKNOWNINVLR: number;
            static IMEINOTACCEPTED: number;
            static ILLEGALME: number;
            static PSSERVICESNOTALLOWED: number;
            static PSANDNONPSSERVICESNOTALLOWED: number;
            static UEIDENTITYNOTDERIVEDFROMNETWORK: number;
            static IMPLICITLYDETACHED: number;
            static PLMNNOTALLOWED: number;
            static AREANOTALLOWED: number;
            static ROAMINGNOTALLOWEDINAREA: number;
            static PSSERVICESNOTALLOWEDINPLMN: number;
            static NOCELLSINAREA: number;
            static MSCTEMPORARILYNOTREACHABLE: number;
            static NETWORKFAILUREATTACH: number;
            static CSDOMAINUNAVAILABLE: number;
            static ESMFAILURE: number;
            static CONGESTION: number;
            static MBMSBEARERCAPABILITIESINSUFFICIENTFORSERVICE: number;
            static NOTAUTHORIZEDFORCSG: number;
            static INSUFFICIENTRESOURCES: number;
            static MISSINGORUNKNOWNAPN: number;
            static UNKNOWNPDPADDRESSORTYPE: number;
            static USERAUTHENTICATIONFAILED: number;
            static ACTIVATIONREJECTEDBYGGSNORGW: number;
            static ACTIVATIONREJECTEDUNSPECIFIED: number;
            static SERVICEOPTIONNOTSUPPORTED: number;
            static SERVICEOPTIONNOTSUBSCRIBED: number;
            static SERVICEOPTIONOUTOFORDER: number;
            static NSAPIORPTIALREADYINUSE: number;
            static REGULARDEACTIVATION: number;
            static QOSNOTACCEPTED: number;
            static CALLCANNOTBEIDENTIFIED: number;
            static CSSERVICETEMPORARILYUNAVAILABLE: number;
            static FEATURENOTSUPPORTED: number;
            static SEMANTICERRORINTFTOPERATION: number;
            static SYNTACTICALERRORINTFTOPERATION: number;
            static UNKNOWNPDPCONTEXT: number;
            static SEMANTICERRORSINPACKETFILTER: number;
            static SYNTACTICALERRORSINPACKETFILTER: number;
            static PDPCONTEXTWITHOUTTFTALREADYACTIVATED: number;
            static MULTICASTGROUPMEMBERSHIPTIMEOUT: number;
            static GPRSUNKNOWN: number;
            static PDPAUTHFAILURE: number;
            static INVALIDMOBILECLASS: number;
            static LASTPDNDISCONNECTIONNOTALLOWEDLEGACY: number;
            static LASTPDNDISCONNECTIONNOTALLOWED: number;
            static SEMANTICALLYINCORRECTMESSAGE: number;
            static INVALIDMANDATORYINFORMATION: number;
            static MESSAGETYPENOTIMPLEMENTED: number;
            static CONDITIONALIEERROR: number;
            static UNSPECIFIEDPROTOCOLERROR: number;
            static OPERATORDETERMINEDBARRING: number;
            static MAXIMUMNUMBEROFBEARERSREACHED: number;
            static REQUESTEDAPNNOTSUPPORTED: number;
            static REQUESTREJECTEDBCMVIOLATION: number;
            static UNSUPPORTEDQCIOR5QIVALUE: number;
            static USERDATAVIACONTROLPLANECONGESTED: number;
            static SMSPROVIDEDVIAGPRSINROUTINGAREA: number;
            static INVALIDPTIVALUE: number;
            static NOBEARERACTIVATED: number;
            static MESSAGENOTCOMPATIBLEWITHPROTOCOLSTATE: number;
            static RECOVERYONTIMEREXPIRY: number;
            static INVALIDTRANSACTIONIDVALUE: number;
            static SERVICEOPTIONNOTAUTHORIZEDINPLMN: number;
            static NETWORKFAILUREACTIVATION: number;
            static REACTIVATIONREQUESTED: number;
            static IPV4ONLYALLOWED: number;
            static IPV6ONLYALLOWED: number;
            static SINGLEADDRESSBEARERSONLYALLOWED: number;
            static COLLISIONWITHNETWORKINITIATEDREQUEST: number;
            static IPV4V6ONLYALLOWED: number;
            static NONIPONLYALLOWED: number;
            static BEARERHANDLINGUNSUPPORTED: number;
            static APNRESTRICTIONINCOMPATIBLE: number;
            static MULTIPLEACCESSTOPDNCONNECTIONNOTALLOWED: number;
            static ESMINFORMATIONNOTRECEIVED: number;
            static PDNCONNECTIONNONEXISTENT: number;
            static MULTIPLEPDNCONNECTIONSAMEAPNNOTALLOWED: number;
            static SEVERENETWORKFAILURE: number;
            static INSUFFICIENTRESOURCESFORSLICEANDDNN: number;
            static UNSUPPORTEDSSCMODE: number;
            static INSUFFICIENTRESOURCESFORSLICE: number;
            static MESSAGETYPENOTCOMPATIBLEWITHPROTOCOLSTATE: number;
            static IENOTIMPLEMENTED: number;
            static N1MODENOTALLOWED: number;
            static RESTRICTEDSERVICEAREA: number;
            static LADNUNAVAILABLE: number;
            static MISSINGORUNKNOWNDNNINSLICE: number;
            static NKGSIALREADYINUSE: number;
            static PAYLOADNOTFORWARDED: number;
            static NON3GPPACCESSTO5GCNNOTALLOWED: number;
            static SERVINGNETWORKNOTAUTHORIZED: number;
            static DNNNOTSUPPORTEDINSLICE: number;
            static INSUFFICIENTUSERPLANERESOURCESFORPDUSESSION: number;
            static OUTOFLADNSERVICEAREA: number;
            static PTIMISMATCH: number;
            static MAXDATARATEFORUSERPLANEINTEGRITYTOOLOW: number;
            static SEMANTICERRORINQOSOPERATION: number;
            static SYNTACTICALERRORINQOSOPERATION: number;
            static INVALIDMAPPEDEPSBEARERIDENTITY: number;
            static REDIRECTIONTO5GCNREQUIRED: number;
            static REDIRECTIONTOEPCREQUIRED: number;
            static TEMPORARILYUNAUTHORIZEDFORSNPN: number;
            static PERMANENTLYUNAUTHORIZEDFORSNPN: number;
            static ETHERNETONLYALLOWED: number;
            static UNAUTHORIZEDFORCAG: number;
            static NONETWORKSLICESAVAILABLE: number;
            static WIRELINEACCESSAREANOTALLOWED: number;

            // Constructors

            constructor(options: { message: string; code: number });
            _init(...args: any[]): void;

            // Static methods

            static quark(): GLib.Quark;
        }

        class Modem3gppDrxCycle {
            static $gtype: GObject.GType<Modem3gppDrxCycle>;

            // Static fields

            static UNKNOWN: number;
            static UNSUPPORTED: number;
            static '32': number;
            static '64': number;
            static '128': number;
            static '256': number;

            // Constructors

            _init(...args: any[]): void;
        }

        export namespace Modem3gppEpsUeModeOperation {
            export const $gtype: GObject.GType<Modem3gppEpsUeModeOperation>;
        }

        enum Modem3gppEpsUeModeOperation {
            UNKNOWN,
            PS_1,
            PS_2,
            CSPS_1,
            CSPS_2,
        }

        export namespace Modem3gppMicoMode {
            export const $gtype: GObject.GType<Modem3gppMicoMode>;
        }

        enum Modem3gppMicoMode {
            UNKNOWN,
            UNSUPPORTED,
            DISABLED,
            ENABLED,
        }

        export namespace Modem3gppNetworkAvailability {
            export const $gtype: GObject.GType<Modem3gppNetworkAvailability>;
        }

        enum Modem3gppNetworkAvailability {
            UNKNOWN,
            AVAILABLE,
            CURRENT,
            FORBIDDEN,
        }

        export namespace Modem3gppPacketServiceState {
            export const $gtype: GObject.GType<Modem3gppPacketServiceState>;
        }

        enum Modem3gppPacketServiceState {
            UNKNOWN,
            DETACHED,
            ATTACHED,
        }

        export namespace Modem3gppRegistrationState {
            export const $gtype: GObject.GType<Modem3gppRegistrationState>;
        }

        enum Modem3gppRegistrationState {
            IDLE,
            HOME,
            SEARCHING,
            DENIED,
            UNKNOWN,
            ROAMING,
            HOME_SMS_ONLY,
            ROAMING_SMS_ONLY,
            EMERGENCY_ONLY,
            HOME_CSFB_NOT_PREFERRED,
            ROAMING_CSFB_NOT_PREFERRED,
            ATTACHED_RLOS,
        }

        export namespace Modem3gppSubscriptionState {
            export const $gtype: GObject.GType<Modem3gppSubscriptionState>;
        }

        enum Modem3gppSubscriptionState {
            UNKNOWN,
            UNPROVISIONED,
            PROVISIONED,
            OUT_OF_DATA,
        }

        export namespace Modem3gppUssdSessionState {
            export const $gtype: GObject.GType<Modem3gppUssdSessionState>;
        }

        enum Modem3gppUssdSessionState {
            UNKNOWN,
            IDLE,
            ACTIVE,
            USER_RESPONSE,
        }

        export namespace ModemBand {
            export const $gtype: GObject.GType<ModemBand>;
        }

        enum ModemBand {
            UNKNOWN,
            EGSM,
            DCS,
            PCS,
            G850,
            UTRAN_1,
            UTRAN_3,
            UTRAN_4,
            UTRAN_6,
            UTRAN_5,
            UTRAN_8,
            UTRAN_9,
            UTRAN_2,
            UTRAN_7,
            G450,
            G480,
            G750,
            G380,
            G410,
            G710,
            G810,
            EUTRAN_1,
            EUTRAN_2,
            EUTRAN_3,
            EUTRAN_4,
            EUTRAN_5,
            EUTRAN_6,
            EUTRAN_7,
            EUTRAN_8,
            EUTRAN_9,
            EUTRAN_10,
            EUTRAN_11,
            EUTRAN_12,
            EUTRAN_13,
            EUTRAN_14,
            EUTRAN_17,
            EUTRAN_18,
            EUTRAN_19,
            EUTRAN_20,
            EUTRAN_21,
            EUTRAN_22,
            EUTRAN_23,
            EUTRAN_24,
            EUTRAN_25,
            EUTRAN_26,
            EUTRAN_27,
            EUTRAN_28,
            EUTRAN_29,
            EUTRAN_30,
            EUTRAN_31,
            EUTRAN_32,
            EUTRAN_33,
            EUTRAN_34,
            EUTRAN_35,
            EUTRAN_36,
            EUTRAN_37,
            EUTRAN_38,
            EUTRAN_39,
            EUTRAN_40,
            EUTRAN_41,
            EUTRAN_42,
            EUTRAN_43,
            EUTRAN_44,
            EUTRAN_45,
            EUTRAN_46,
            EUTRAN_47,
            EUTRAN_48,
            EUTRAN_49,
            EUTRAN_50,
            EUTRAN_51,
            EUTRAN_52,
            EUTRAN_53,
            EUTRAN_54,
            EUTRAN_55,
            EUTRAN_56,
            EUTRAN_57,
            EUTRAN_58,
            EUTRAN_59,
            EUTRAN_60,
            EUTRAN_61,
            EUTRAN_62,
            EUTRAN_63,
            EUTRAN_64,
            EUTRAN_65,
            EUTRAN_66,
            EUTRAN_67,
            EUTRAN_68,
            EUTRAN_69,
            EUTRAN_70,
            EUTRAN_71,
            EUTRAN_85,
            CDMA_BC0,
            CDMA_BC1,
            CDMA_BC2,
            CDMA_BC3,
            CDMA_BC4,
            CDMA_BC5,
            CDMA_BC6,
            CDMA_BC7,
            CDMA_BC8,
            CDMA_BC9,
            CDMA_BC10,
            CDMA_BC11,
            CDMA_BC12,
            CDMA_BC13,
            CDMA_BC14,
            CDMA_BC15,
            CDMA_BC16,
            CDMA_BC17,
            CDMA_BC18,
            CDMA_BC19,
            UTRAN_10,
            UTRAN_11,
            UTRAN_12,
            UTRAN_13,
            UTRAN_14,
            UTRAN_19,
            UTRAN_20,
            UTRAN_21,
            UTRAN_22,
            UTRAN_25,
            UTRAN_26,
            UTRAN_32,
            ANY,
            NGRAN_1,
            NGRAN_2,
            NGRAN_3,
            NGRAN_5,
            NGRAN_7,
            NGRAN_8,
            NGRAN_12,
            NGRAN_13,
            NGRAN_14,
            NGRAN_18,
            NGRAN_20,
            NGRAN_25,
            NGRAN_26,
            NGRAN_28,
            NGRAN_29,
            NGRAN_30,
            NGRAN_34,
            NGRAN_38,
            NGRAN_39,
            NGRAN_40,
            NGRAN_41,
            NGRAN_48,
            NGRAN_50,
            NGRAN_51,
            NGRAN_53,
            NGRAN_65,
            NGRAN_66,
            NGRAN_70,
            NGRAN_71,
            NGRAN_74,
            NGRAN_75,
            NGRAN_76,
            NGRAN_77,
            NGRAN_78,
            NGRAN_79,
            NGRAN_80,
            NGRAN_81,
            NGRAN_82,
            NGRAN_83,
            NGRAN_84,
            NGRAN_86,
            NGRAN_89,
            NGRAN_90,
            NGRAN_91,
            NGRAN_92,
            NGRAN_93,
            NGRAN_94,
            NGRAN_95,
            NGRAN_257,
            NGRAN_258,
            NGRAN_260,
            NGRAN_261,
        }

        export namespace ModemCdmaActivationState {
            export const $gtype: GObject.GType<ModemCdmaActivationState>;
        }

        enum ModemCdmaActivationState {
            UNKNOWN,
            NOT_ACTIVATED,
            ACTIVATING,
            PARTIALLY_ACTIVATED,
            ACTIVATED,
        }

        export namespace ModemCdmaRegistrationState {
            export const $gtype: GObject.GType<ModemCdmaRegistrationState>;
        }

        enum ModemCdmaRegistrationState {
            UNKNOWN,
            REGISTERED,
            HOME,
            ROAMING,
        }

        export namespace ModemCdmaRmProtocol {
            export const $gtype: GObject.GType<ModemCdmaRmProtocol>;
        }

        enum ModemCdmaRmProtocol {
            UNKNOWN,
            ASYNC,
            PACKET_RELAY,
            PACKET_NETWORK_PPP,
            PACKET_NETWORK_SLIP,
            STU_III,
        }

        export namespace ModemContactsStorage {
            export const $gtype: GObject.GType<ModemContactsStorage>;
        }

        enum ModemContactsStorage {
            UNKNOWN,
            ME,
            SM,
            MT,
        }

        export namespace ModemLock {
            export const $gtype: GObject.GType<ModemLock>;
        }

        enum ModemLock {
            UNKNOWN,
            NONE,
            SIM_PIN,
            SIM_PIN2,
            SIM_PUK,
            SIM_PUK2,
            PH_SP_PIN,
            PH_SP_PUK,
            PH_NET_PIN,
            PH_NET_PUK,
            PH_SIM_PIN,
            PH_CORP_PIN,
            PH_CORP_PUK,
            PH_FSIM_PIN,
            PH_FSIM_PUK,
            PH_NETSUB_PIN,
            PH_NETSUB_PUK,
        }

        export namespace ModemPortType {
            export const $gtype: GObject.GType<ModemPortType>;
        }

        enum ModemPortType {
            UNKNOWN,
            NET,
            AT,
            QCDM,
            GPS,
            QMI,
            MBIM,
            AUDIO,
            IGNORED,
        }

        export namespace ModemPowerState {
            export const $gtype: GObject.GType<ModemPowerState>;
        }

        enum ModemPowerState {
            UNKNOWN,
            OFF,
            LOW,
            ON,
        }

        export namespace ModemState {
            export const $gtype: GObject.GType<ModemState>;
        }

        enum ModemState {
            FAILED,
            UNKNOWN,
            INITIALIZING,
            LOCKED,
            DISABLED,
            DISABLING,
            ENABLING,
            ENABLED,
            SEARCHING,
            REGISTERED,
            DISCONNECTING,
            CONNECTING,
            CONNECTED,
        }

        export namespace ModemStateChangeReason {
            export const $gtype: GObject.GType<ModemStateChangeReason>;
        }

        enum ModemStateChangeReason {
            UNKNOWN,
            USER_REQUESTED,
            SUSPEND,
            FAILURE,
        }

        export namespace ModemStateFailedReason {
            export const $gtype: GObject.GType<ModemStateFailedReason>;
        }

        enum ModemStateFailedReason {
            NONE,
            UNKNOWN,
            SIM_MISSING,
            SIM_ERROR,
            UNKNOWN_CAPABILITIES,
            ESIM_WITHOUT_PROFILES,
        }

        export namespace OmaSessionState {
            export const $gtype: GObject.GType<OmaSessionState>;
        }

        enum OmaSessionState {
            FAILED,
            UNKNOWN,
            STARTED,
            RETRYING,
            CONNECTING,
            CONNECTED,
            AUTHENTICATED,
            MDN_DOWNLOADED,
            MSID_DOWNLOADED,
            PRL_DOWNLOADED,
            MIP_PROFILE_DOWNLOADED,
            COMPLETED,
        }

        export namespace OmaSessionStateFailedReason {
            export const $gtype: GObject.GType<OmaSessionStateFailedReason>;
        }

        enum OmaSessionStateFailedReason {
            UNKNOWN,
            NETWORK_UNAVAILABLE,
            SERVER_UNAVAILABLE,
            AUTHENTICATION_FAILED,
            MAX_RETRY_EXCEEDED,
            SESSION_CANCELLED,
        }

        export namespace OmaSessionType {
            export const $gtype: GObject.GType<OmaSessionType>;
        }

        enum OmaSessionType {
            UNKNOWN,
            CLIENT_INITIATED_DEVICE_CONFIGURE,
            CLIENT_INITIATED_PRL_UPDATE,
            CLIENT_INITIATED_HANDS_FREE_ACTIVATION,
            NETWORK_INITIATED_DEVICE_CONFIGURE,
            NETWORK_INITIATED_PRL_UPDATE,
            DEVICE_INITIATED_PRL_UPDATE,
            DEVICE_INITIATED_HANDS_FREE_ACTIVATION,
        }
        class SerialError extends GLib.Error {
            static $gtype: GObject.GType<SerialError>;

            // Static fields

            static UNKNOWN: number;
            static OPENFAILED: number;
            static SENDFAILED: number;
            static RESPONSETIMEOUT: number;
            static OPENFAILEDNODEVICE: number;
            static FLASHFAILED: number;
            static NOTOPEN: number;
            static PARSEFAILED: number;
            static FRAMENOTFOUND: number;

            // Constructors

            constructor(options: { message: string; code: number });
            _init(...args: any[]): void;

            // Static methods

            static quark(): GLib.Quark;
        }

        export namespace ServingCellType {
            export const $gtype: GObject.GType<ServingCellType>;
        }

        enum ServingCellType {
            UNKNOWN,
            PCELL,
            SCELL,
            PSCELL,
            SSCELL,
            INVALID,
        }

        export namespace SimEsimStatus {
            export const $gtype: GObject.GType<SimEsimStatus>;
        }

        enum SimEsimStatus {
            UNKNOWN,
            NO_PROFILES,
            WITH_PROFILES,
        }

        export namespace SimRemovability {
            export const $gtype: GObject.GType<SimRemovability>;
        }

        enum SimRemovability {
            UNKNOWN,
            REMOVABLE,
            NOT_REMOVABLE,
        }

        export namespace SimType {
            export const $gtype: GObject.GType<SimType>;
        }

        enum SimType {
            UNKNOWN,
            PHYSICAL,
            ESIM,
        }

        export namespace SmsCdmaServiceCategory {
            export const $gtype: GObject.GType<SmsCdmaServiceCategory>;
        }

        enum SmsCdmaServiceCategory {
            UNKNOWN,
            EMERGENCY_BROADCAST,
            ADMINISTRATIVE,
            MAINTENANCE,
            GENERAL_NEWS_LOCAL,
            GENERAL_NEWS_REGIONAL,
            GENERAL_NEWS_NATIONAL,
            GENERAL_NEWS_INTERNATIONAL,
            BUSINESS_NEWS_LOCAL,
            BUSINESS_NEWS_REGIONAL,
            BUSINESS_NEWS_NATIONAL,
            BUSINESS_NEWS_INTERNATIONAL,
            SPORTS_NEWS_LOCAL,
            SPORTS_NEWS_REGIONAL,
            SPORTS_NEWS_NATIONAL,
            SPORTS_NEWS_INTERNATIONAL,
            ENTERTAINMENT_NEWS_LOCAL,
            ENTERTAINMENT_NEWS_REGIONAL,
            ENTERTAINMENT_NEWS_NATIONAL,
            ENTERTAINMENT_NEWS_INTERNATIONAL,
            LOCAL_WEATHER,
            TRAFFIC_REPORT,
            FLIGHT_SCHEDULES,
            RESTAURANTS,
            LODGINGS,
            RETAIL_DIRECTORY,
            ADVERTISEMENTS,
            STOCK_QUOTES,
            EMPLOYMENT,
            HOSPITALS,
            TECHNOLOGY_NEWS,
            MULTICATEGORY,
            CMAS_PRESIDENTIAL_ALERT,
            CMAS_EXTREME_THREAT,
            CMAS_SEVERE_THREAT,
            CMAS_CHILD_ABDUCTION_EMERGENCY,
            CMAS_TEST,
        }

        export namespace SmsCdmaTeleserviceId {
            export const $gtype: GObject.GType<SmsCdmaTeleserviceId>;
        }

        enum SmsCdmaTeleserviceId {
            UNKNOWN,
            CMT91,
            WPT,
            WMT,
            VMN,
            WAP,
            WEMT,
            SCPT,
            CATPT,
        }

        export namespace SmsDeliveryState {
            export const $gtype: GObject.GType<SmsDeliveryState>;
        }

        enum SmsDeliveryState {
            COMPLETED_RECEIVED,
            COMPLETED_FORWARDED_UNCONFIRMED,
            COMPLETED_REPLACED_BY_SC,
            TEMPORARY_ERROR_CONGESTION,
            TEMPORARY_ERROR_SME_BUSY,
            TEMPORARY_ERROR_NO_RESPONSE_FROM_SME,
            TEMPORARY_ERROR_SERVICE_REJECTED,
            TEMPORARY_ERROR_QOS_NOT_AVAILABLE,
            TEMPORARY_ERROR_IN_SME,
            ERROR_REMOTE_PROCEDURE,
            ERROR_INCOMPATIBLE_DESTINATION,
            ERROR_CONNECTION_REJECTED,
            ERROR_NOT_OBTAINABLE,
            ERROR_QOS_NOT_AVAILABLE,
            ERROR_NO_INTERWORKING_AVAILABLE,
            ERROR_VALIDITY_PERIOD_EXPIRED,
            ERROR_DELETED_BY_ORIGINATING_SME,
            ERROR_DELETED_BY_SC_ADMINISTRATION,
            ERROR_MESSAGE_DOES_NOT_EXIST,
            TEMPORARY_FATAL_ERROR_CONGESTION,
            TEMPORARY_FATAL_ERROR_SME_BUSY,
            TEMPORARY_FATAL_ERROR_NO_RESPONSE_FROM_SME,
            TEMPORARY_FATAL_ERROR_SERVICE_REJECTED,
            TEMPORARY_FATAL_ERROR_QOS_NOT_AVAILABLE,
            TEMPORARY_FATAL_ERROR_IN_SME,
            UNKNOWN,
            NETWORK_PROBLEM_ADDRESS_VACANT,
            NETWORK_PROBLEM_ADDRESS_TRANSLATION_FAILURE,
            NETWORK_PROBLEM_NETWORK_RESOURCE_OUTAGE,
            NETWORK_PROBLEM_NETWORK_FAILURE,
            NETWORK_PROBLEM_INVALID_TELESERVICE_ID,
            NETWORK_PROBLEM_OTHER,
            TERMINAL_PROBLEM_NO_PAGE_RESPONSE,
            TERMINAL_PROBLEM_DESTINATION_BUSY,
            TERMINAL_PROBLEM_NO_ACKNOWLEDGMENT,
            TERMINAL_PROBLEM_DESTINATION_RESOURCE_SHORTAGE,
            TERMINAL_PROBLEM_SMS_DELIVERY_POSTPONED,
            TERMINAL_PROBLEM_DESTINATION_OUT_OF_SERVICE,
            TERMINAL_PROBLEM_DESTINATION_NO_LONGER_AT_THIS_ADDRESS,
            TERMINAL_PROBLEM_OTHER,
            RADIO_INTERFACE_PROBLEM_RESOURCE_SHORTAGE,
            RADIO_INTERFACE_PROBLEM_INCOMPATIBILITY,
            RADIO_INTERFACE_PROBLEM_OTHER,
            GENERAL_PROBLEM_ENCODING,
            GENERAL_PROBLEM_SMS_ORIGINATION_DENIED,
            GENERAL_PROBLEM_SMS_TERMINATION_DENIED,
            GENERAL_PROBLEM_SUPPLEMENTARY_SERVICE_NOT_SUPPORTED,
            GENERAL_PROBLEM_SMS_NOT_SUPPORTED,
            GENERAL_PROBLEM_MISSING_EXPECTED_PARAMETER,
            GENERAL_PROBLEM_MISSING_MANDATORY_PARAMETER,
            GENERAL_PROBLEM_UNRECOGNIZED_PARAMETER_VALUE,
            GENERAL_PROBLEM_UNEXPECTED_PARAMETER_VALUE,
            GENERAL_PROBLEM_USER_DATA_SIZE_ERROR,
            GENERAL_PROBLEM_OTHER,
            TEMPORARY_NETWORK_PROBLEM_ADDRESS_VACANT,
            TEMPORARY_NETWORK_PROBLEM_ADDRESS_TRANSLATION_FAILURE,
            TEMPORARY_NETWORK_PROBLEM_NETWORK_RESOURCE_OUTAGE,
            TEMPORARY_NETWORK_PROBLEM_NETWORK_FAILURE,
            TEMPORARY_NETWORK_PROBLEM_INVALID_TELESERVICE_ID,
            TEMPORARY_NETWORK_PROBLEM_OTHER,
            TEMPORARY_TERMINAL_PROBLEM_NO_PAGE_RESPONSE,
            TEMPORARY_TERMINAL_PROBLEM_DESTINATION_BUSY,
            TEMPORARY_TERMINAL_PROBLEM_NO_ACKNOWLEDGMENT,
            TEMPORARY_TERMINAL_PROBLEM_DESTINATION_RESOURCE_SHORTAGE,
            TEMPORARY_TERMINAL_PROBLEM_SMS_DELIVERY_POSTPONED,
            TEMPORARY_TERMINAL_PROBLEM_DESTINATION_OUT_OF_SERVICE,
            TEMPORARY_TERMINAL_PROBLEM_DESTINATION_NO_LONGER_AT_THIS_ADDRESS,
            TEMPORARY_TERMINAL_PROBLEM_OTHER,
            TEMPORARY_RADIO_INTERFACE_PROBLEM_RESOURCE_SHORTAGE,
            TEMPORARY_RADIO_INTERFACE_PROBLEM_INCOMPATIBILITY,
            TEMPORARY_RADIO_INTERFACE_PROBLEM_OTHER,
            TEMPORARY_GENERAL_PROBLEM_ENCODING,
            TEMPORARY_GENERAL_PROBLEM_SMS_ORIGINATION_DENIED,
            TEMPORARY_GENERAL_PROBLEM_SMS_TERMINATION_DENIED,
            TEMPORARY_GENERAL_PROBLEM_SUPPLEMENTARY_SERVICE_NOT_SUPPORTED,
            TEMPORARY_GENERAL_PROBLEM_SMS_NOT_SUPPORTED,
            TEMPORARY_GENERAL_PROBLEM_MISSING_EXPECTED_PARAMETER,
            TEMPORARY_GENERAL_PROBLEM_MISSING_MANDATORY_PARAMETER,
            TEMPORARY_GENERAL_PROBLEM_UNRECOGNIZED_PARAMETER_VALUE,
            TEMPORARY_GENERAL_PROBLEM_UNEXPECTED_PARAMETER_VALUE,
            TEMPORARY_GENERAL_PROBLEM_USER_DATA_SIZE_ERROR,
            TEMPORARY_GENERAL_PROBLEM_OTHER,
        }

        export namespace SmsPduType {
            export const $gtype: GObject.GType<SmsPduType>;
        }

        enum SmsPduType {
            UNKNOWN,
            DELIVER,
            SUBMIT,
            STATUS_REPORT,
            CDMA_DELIVER,
            CDMA_SUBMIT,
            CDMA_CANCELLATION,
            CDMA_DELIVERY_ACKNOWLEDGEMENT,
            CDMA_USER_ACKNOWLEDGEMENT,
            CDMA_READ_ACKNOWLEDGEMENT,
        }

        export namespace SmsState {
            export const $gtype: GObject.GType<SmsState>;
        }

        enum SmsState {
            UNKNOWN,
            STORED,
            RECEIVING,
            RECEIVED,
            SENDING,
            SENT,
        }

        export namespace SmsStorage {
            export const $gtype: GObject.GType<SmsStorage>;
        }

        enum SmsStorage {
            UNKNOWN,
            SM,
            ME,
            MT,
            SR,
            BM,
            TA,
        }

        export namespace SmsValidityType {
            export const $gtype: GObject.GType<SmsValidityType>;
        }

        enum SmsValidityType {
            UNKNOWN,
            RELATIVE,
            ABSOLUTE,
            ENHANCED,
        }
        /**
         * This value may be specified in the 'profile-id' property When the user
         * creates a new #MM3gppProfile, to indicate that the real profile id should
         * be assigned by the device.
         */
        const __3GPP_PROFILE_ID_UNKNOWN: number;
        const BEARER_METHOD_CONNECT: string;
        const BEARER_METHOD_DISCONNECT: string;
        const BEARER_PROPERTY_BEARERTYPE: string;
        const BEARER_PROPERTY_CONNECTED: string;
        const BEARER_PROPERTY_CONNECTIONERROR: string;
        const BEARER_PROPERTY_INTERFACE: string;
        const BEARER_PROPERTY_IP4CONFIG: string;
        const BEARER_PROPERTY_IP6CONFIG: string;
        const BEARER_PROPERTY_IPTIMEOUT: string;
        const BEARER_PROPERTY_MULTIPLEXED: string;
        const BEARER_PROPERTY_PROFILEID: string;
        const BEARER_PROPERTY_PROPERTIES: string;
        const BEARER_PROPERTY_RELOADSTATSSUPPORTED: string;
        const BEARER_PROPERTY_STATS: string;
        const BEARER_PROPERTY_SUSPENDED: string;
        const CALL_METHOD_ACCEPT: string;
        const CALL_METHOD_DEFLECT: string;
        const CALL_METHOD_HANGUP: string;
        const CALL_METHOD_JOINMULTIPARTY: string;
        const CALL_METHOD_LEAVEMULTIPARTY: string;
        const CALL_METHOD_SENDDTMF: string;
        const CALL_METHOD_START: string;
        const CALL_PROPERTY_AUDIOFORMAT: string;
        const CALL_PROPERTY_AUDIOPORT: string;
        const CALL_PROPERTY_DIRECTION: string;
        const CALL_PROPERTY_MULTIPARTY: string;
        const CALL_PROPERTY_NUMBER: string;
        const CALL_PROPERTY_STATE: string;
        const CALL_PROPERTY_STATEREASON: string;
        const CALL_SIGNAL_DTMFRECEIVED: string;
        const CALL_SIGNAL_STATECHANGED: string;
        const DBUS_ERROR_PREFIX: string;
        const DBUS_INTERFACE: string;
        const DBUS_INTERFACE_BEARER: string;
        const DBUS_INTERFACE_CALL: string;
        const DBUS_INTERFACE_MODEM: string;
        const DBUS_INTERFACE_MODEM_FIRMWARE: string;
        const DBUS_INTERFACE_MODEM_LOCATION: string;
        const DBUS_INTERFACE_MODEM_MESSAGING: string;
        const DBUS_INTERFACE_MODEM_MODEM3GPP: string;
        const DBUS_INTERFACE_MODEM_MODEM3GPP_PROFILEMANAGER: string;
        const DBUS_INTERFACE_MODEM_MODEM3GPP_USSD: string;
        const DBUS_INTERFACE_MODEM_MODEMCDMA: string;
        const DBUS_INTERFACE_MODEM_OMA: string;
        const DBUS_INTERFACE_MODEM_SAR: string;
        const DBUS_INTERFACE_MODEM_SIGNAL: string;
        const DBUS_INTERFACE_MODEM_SIMPLE: string;
        const DBUS_INTERFACE_MODEM_TIME: string;
        const DBUS_INTERFACE_MODEM_VOICE: string;
        const DBUS_INTERFACE_SIM: string;
        const DBUS_INTERFACE_SMS: string;
        const DBUS_PATH: string;
        const DBUS_SERVICE: string;
        /**
         * Evaluates to the major version number of ModemManager which this source
         * is compiled against.
         */
        const MAJOR_VERSION: number;
        const MANAGER_METHOD_INHIBITDEVICE: string;
        const MANAGER_METHOD_REPORTKERNELEVENT: string;
        const MANAGER_METHOD_SCANDEVICES: string;
        const MANAGER_METHOD_SETLOGGING: string;
        const MANAGER_PROPERTY_VERSION: string;
        /**
         * Evaluates to the micro version number of ModemManager which this source
         * compiled against.
         */
        const MICRO_VERSION: number;
        /**
         * Evaluates to the minor version number of ModemManager which this source
         * is compiled against.
         */
        const MINOR_VERSION: number;
        /**
         * Identifier for an unknown NID.
         */
        const MODEM_CDMA_NID_UNKNOWN: number;
        /**
         * Identifier for an unknown SID.
         */
        const MODEM_CDMA_SID_UNKNOWN: number;
        const MODEM_FIRMWARE_METHOD_LIST: string;
        const MODEM_FIRMWARE_METHOD_SELECT: string;
        const MODEM_FIRMWARE_PROPERTY_UPDATESETTINGS: string;
        const MODEM_LOCATION_METHOD_GETLOCATION: string;
        const MODEM_LOCATION_METHOD_INJECTASSISTANCEDATA: string;
        const MODEM_LOCATION_METHOD_SETGPSREFRESHRATE: string;
        const MODEM_LOCATION_METHOD_SETSUPLSERVER: string;
        const MODEM_LOCATION_METHOD_SETUP: string;
        const MODEM_LOCATION_PROPERTY_ASSISTANCEDATASERVERS: string;
        const MODEM_LOCATION_PROPERTY_CAPABILITIES: string;
        const MODEM_LOCATION_PROPERTY_ENABLED: string;
        const MODEM_LOCATION_PROPERTY_GPSREFRESHRATE: string;
        const MODEM_LOCATION_PROPERTY_LOCATION: string;
        const MODEM_LOCATION_PROPERTY_SIGNALSLOCATION: string;
        const MODEM_LOCATION_PROPERTY_SUPLSERVER: string;
        const MODEM_LOCATION_PROPERTY_SUPPORTEDASSISTANCEDATA: string;
        const MODEM_MESSAGING_METHOD_CREATE: string;
        const MODEM_MESSAGING_METHOD_DELETE: string;
        const MODEM_MESSAGING_METHOD_LIST: string;
        const MODEM_MESSAGING_PROPERTY_DEFAULTSTORAGE: string;
        const MODEM_MESSAGING_PROPERTY_MESSAGES: string;
        const MODEM_MESSAGING_PROPERTY_SUPPORTEDSTORAGES: string;
        const MODEM_MESSAGING_SIGNAL_ADDED: string;
        const MODEM_MESSAGING_SIGNAL_DELETED: string;
        const MODEM_METHOD_COMMAND: string;
        const MODEM_METHOD_CREATEBEARER: string;
        const MODEM_METHOD_DELETEBEARER: string;
        const MODEM_METHOD_ENABLE: string;
        const MODEM_METHOD_FACTORYRESET: string;
        const MODEM_METHOD_GETCELLINFO: string;
        const MODEM_METHOD_LISTBEARERS: string;
        const MODEM_METHOD_RESET: string;
        const MODEM_METHOD_SETCURRENTBANDS: string;
        const MODEM_METHOD_SETCURRENTCAPABILITIES: string;
        const MODEM_METHOD_SETCURRENTMODES: string;
        const MODEM_METHOD_SETPOWERSTATE: string;
        const MODEM_METHOD_SETPRIMARYSIMSLOT: string;
        const MODEM_MODEM3GPP_METHOD_DISABLEFACILITYLOCK: string;
        const MODEM_MODEM3GPP_METHOD_REGISTER: string;
        const MODEM_MODEM3GPP_METHOD_SCAN: string;
        const MODEM_MODEM3GPP_METHOD_SETCARRIERLOCK: string;
        const MODEM_MODEM3GPP_METHOD_SETEPSUEMODEOPERATION: string;
        const MODEM_MODEM3GPP_METHOD_SETINITIALEPSBEARERSETTINGS: string;
        const MODEM_MODEM3GPP_METHOD_SETNR5GREGISTRATIONSETTINGS: string;
        const MODEM_MODEM3GPP_METHOD_SETPACKETSERVICESTATE: string;
        const MODEM_MODEM3GPP_PROFILEMANAGER_METHOD_DELETE: string;
        const MODEM_MODEM3GPP_PROFILEMANAGER_METHOD_LIST: string;
        const MODEM_MODEM3GPP_PROFILEMANAGER_METHOD_SET: string;
        const MODEM_MODEM3GPP_PROFILEMANAGER_PROPERTY_INDEXFIELD: string;
        const MODEM_MODEM3GPP_PROFILEMANAGER_SIGNAL_UPDATED: string;
        const MODEM_MODEM3GPP_PROPERTY_ENABLEDFACILITYLOCKS: string;
        const MODEM_MODEM3GPP_PROPERTY_EPSUEMODEOPERATION: string;
        const MODEM_MODEM3GPP_PROPERTY_IMEI: string;
        const MODEM_MODEM3GPP_PROPERTY_INITIALEPSBEARER: string;
        const MODEM_MODEM3GPP_PROPERTY_INITIALEPSBEARERSETTINGS: string;
        const MODEM_MODEM3GPP_PROPERTY_NR5GREGISTRATIONSETTINGS: string;
        const MODEM_MODEM3GPP_PROPERTY_OPERATORCODE: string;
        const MODEM_MODEM3GPP_PROPERTY_OPERATORNAME: string;
        const MODEM_MODEM3GPP_PROPERTY_PACKETSERVICESTATE: string;
        const MODEM_MODEM3GPP_PROPERTY_PCO: string;
        const MODEM_MODEM3GPP_PROPERTY_REGISTRATIONSTATE: string;
        const MODEM_MODEM3GPP_PROPERTY_SUBSCRIPTIONSTATE: string;
        const MODEM_MODEM3GPP_USSD_METHOD_CANCEL: string;
        const MODEM_MODEM3GPP_USSD_METHOD_INITIATE: string;
        const MODEM_MODEM3GPP_USSD_METHOD_RESPOND: string;
        const MODEM_MODEM3GPP_USSD_PROPERTY_NETWORKNOTIFICATION: string;
        const MODEM_MODEM3GPP_USSD_PROPERTY_NETWORKREQUEST: string;
        const MODEM_MODEM3GPP_USSD_PROPERTY_STATE: string;
        const MODEM_MODEMCDMA_METHOD_ACTIVATE: string;
        const MODEM_MODEMCDMA_METHOD_ACTIVATEMANUAL: string;
        const MODEM_MODEMCDMA_PROPERTY_ACTIVATIONSTATE: string;
        const MODEM_MODEMCDMA_PROPERTY_CDMA1XREGISTRATIONSTATE: string;
        const MODEM_MODEMCDMA_PROPERTY_ESN: string;
        const MODEM_MODEMCDMA_PROPERTY_EVDOREGISTRATIONSTATE: string;
        const MODEM_MODEMCDMA_PROPERTY_MEID: string;
        const MODEM_MODEMCDMA_PROPERTY_NID: string;
        const MODEM_MODEMCDMA_PROPERTY_SID: string;
        const MODEM_MODEMCDMA_SIGNAL_ACTIVATIONSTATECHANGED: string;
        const MODEM_OMA_METHOD_ACCEPTNETWORKINITIATEDSESSION: string;
        const MODEM_OMA_METHOD_CANCELSESSION: string;
        const MODEM_OMA_METHOD_SETUP: string;
        const MODEM_OMA_METHOD_STARTCLIENTINITIATEDSESSION: string;
        const MODEM_OMA_PROPERTY_FEATURES: string;
        const MODEM_OMA_PROPERTY_PENDINGNETWORKINITIATEDSESSIONS: string;
        const MODEM_OMA_PROPERTY_SESSIONSTATE: string;
        const MODEM_OMA_PROPERTY_SESSIONTYPE: string;
        const MODEM_OMA_SIGNAL_SESSIONSTATECHANGED: string;
        const MODEM_PROPERTY_ACCESSTECHNOLOGIES: string;
        const MODEM_PROPERTY_BEARERS: string;
        const MODEM_PROPERTY_CARRIERCONFIGURATION: string;
        const MODEM_PROPERTY_CARRIERCONFIGURATIONREVISION: string;
        const MODEM_PROPERTY_CURRENTBANDS: string;
        const MODEM_PROPERTY_CURRENTCAPABILITIES: string;
        const MODEM_PROPERTY_CURRENTMODES: string;
        const MODEM_PROPERTY_DEVICE: string;
        const MODEM_PROPERTY_DEVICEIDENTIFIER: string;
        const MODEM_PROPERTY_DRIVERS: string;
        const MODEM_PROPERTY_EQUIPMENTIDENTIFIER: string;
        const MODEM_PROPERTY_HARDWAREREVISION: string;
        const MODEM_PROPERTY_MANUFACTURER: string;
        const MODEM_PROPERTY_MAXACTIVEBEARERS: string;
        const MODEM_PROPERTY_MAXACTIVEMULTIPLEXEDBEARERS: string;
        const MODEM_PROPERTY_MAXBEARERS: string;
        const MODEM_PROPERTY_MODEL: string;
        const MODEM_PROPERTY_OWNNUMBERS: string;
        const MODEM_PROPERTY_PHYSDEV: string;
        const MODEM_PROPERTY_PLUGIN: string;
        const MODEM_PROPERTY_PORTS: string;
        const MODEM_PROPERTY_POWERSTATE: string;
        const MODEM_PROPERTY_PRIMARYPORT: string;
        const MODEM_PROPERTY_PRIMARYSIMSLOT: string;
        const MODEM_PROPERTY_REVISION: string;
        const MODEM_PROPERTY_SIGNALQUALITY: string;
        const MODEM_PROPERTY_SIM: string;
        const MODEM_PROPERTY_SIMSLOTS: string;
        const MODEM_PROPERTY_STATE: string;
        const MODEM_PROPERTY_STATEFAILEDREASON: string;
        const MODEM_PROPERTY_SUPPORTEDBANDS: string;
        const MODEM_PROPERTY_SUPPORTEDCAPABILITIES: string;
        const MODEM_PROPERTY_SUPPORTEDIPFAMILIES: string;
        const MODEM_PROPERTY_SUPPORTEDMODES: string;
        const MODEM_PROPERTY_UNLOCKREQUIRED: string;
        const MODEM_PROPERTY_UNLOCKRETRIES: string;
        const MODEM_SAR_METHOD_ENABLE: string;
        const MODEM_SAR_METHOD_SETPOWERLEVEL: string;
        const MODEM_SAR_PROPERTY_POWERLEVEL: string;
        const MODEM_SAR_PROPERTY_STATE: string;
        const MODEM_SIGNAL_METHOD_SETUP: string;
        const MODEM_SIGNAL_METHOD_SETUPTHRESHOLDS: string;
        const MODEM_SIGNAL_PROPERTY_CDMA: string;
        const MODEM_SIGNAL_PROPERTY_ERRORRATETHRESHOLD: string;
        const MODEM_SIGNAL_PROPERTY_EVDO: string;
        const MODEM_SIGNAL_PROPERTY_GSM: string;
        const MODEM_SIGNAL_PROPERTY_LTE: string;
        const MODEM_SIGNAL_PROPERTY_NR5G: string;
        const MODEM_SIGNAL_PROPERTY_RATE: string;
        const MODEM_SIGNAL_PROPERTY_RSSITHRESHOLD: string;
        const MODEM_SIGNAL_PROPERTY_UMTS: string;
        const MODEM_SIGNAL_STATECHANGED: string;
        const MODEM_SIMPLE_METHOD_CONNECT: string;
        const MODEM_SIMPLE_METHOD_DISCONNECT: string;
        const MODEM_SIMPLE_METHOD_GETSTATUS: string;
        const MODEM_TIME_METHOD_GETNETWORKTIME: string;
        const MODEM_TIME_PROPERTY_NETWORKTIMEZONE: string;
        const MODEM_TIME_SIGNAL_NETWORKTIMECHANGED: string;
        const MODEM_VOICE_METHOD_CALLWAITINGQUERY: string;
        const MODEM_VOICE_METHOD_CALLWAITINGSETUP: string;
        const MODEM_VOICE_METHOD_CREATECALL: string;
        const MODEM_VOICE_METHOD_DELETECALL: string;
        const MODEM_VOICE_METHOD_HANGUPALL: string;
        const MODEM_VOICE_METHOD_HANGUPANDACCEPT: string;
        const MODEM_VOICE_METHOD_HOLDANDACCEPT: string;
        const MODEM_VOICE_METHOD_LISTCALLS: string;
        const MODEM_VOICE_METHOD_TRANSFER: string;
        const MODEM_VOICE_PROPERTY_CALLS: string;
        const MODEM_VOICE_PROPERTY_EMERGENCYONLY: string;
        const MODEM_VOICE_SIGNAL_CALLADDED: string;
        const MODEM_VOICE_SIGNAL_CALLDELETED: string;
        const SIMPLE_PROPERTY_3GPP_OPERATOR_CODE: string;
        const SIMPLE_PROPERTY_3GPP_OPERATOR_NAME: string;
        const SIMPLE_PROPERTY_3GPP_REGISTRATION_STATE: string;
        const SIMPLE_PROPERTY_3GPP_SUBSCRIPTION_STATE: string;
        const SIMPLE_PROPERTY_ACCESS_TECHNOLOGIES: string;
        const SIMPLE_PROPERTY_CDMA_CDMA1X_REGISTRATION_STATE: string;
        const SIMPLE_PROPERTY_CDMA_EVDO_REGISTRATION_STATE: string;
        const SIMPLE_PROPERTY_CDMA_NID: string;
        const SIMPLE_PROPERTY_CDMA_SID: string;
        const SIMPLE_PROPERTY_CURRENT_BANDS: string;
        const SIMPLE_PROPERTY_SIGNAL_QUALITY: string;
        const SIMPLE_PROPERTY_STATE: string;
        const SIM_METHOD_CHANGEPIN: string;
        const SIM_METHOD_ENABLEPIN: string;
        const SIM_METHOD_SENDPIN: string;
        const SIM_METHOD_SENDPUK: string;
        const SIM_METHOD_SETPREFERREDNETWORKS: string;
        const SIM_PROPERTY_ACTIVE: string;
        const SIM_PROPERTY_EID: string;
        const SIM_PROPERTY_EMERGENCYNUMBERS: string;
        const SIM_PROPERTY_ESIMSTATUS: string;
        const SIM_PROPERTY_GID1: string;
        const SIM_PROPERTY_GID2: string;
        const SIM_PROPERTY_IMSI: string;
        const SIM_PROPERTY_OPERATORIDENTIFIER: string;
        const SIM_PROPERTY_OPERATORNAME: string;
        const SIM_PROPERTY_PREFERREDNETWORKS: string;
        const SIM_PROPERTY_REMOVABILITY: string;
        const SIM_PROPERTY_SIMIDENTIFIER: string;
        const SIM_PROPERTY_SIMTYPE: string;
        const SMS_METHOD_SEND: string;
        const SMS_METHOD_STORE: string;
        const SMS_PROPERTY_CLASS: string;
        const SMS_PROPERTY_DATA: string;
        const SMS_PROPERTY_DELIVERYREPORTREQUEST: string;
        const SMS_PROPERTY_DELIVERYSTATE: string;
        const SMS_PROPERTY_DISCHARGETIMESTAMP: string;
        const SMS_PROPERTY_MESSAGEREFERENCE: string;
        const SMS_PROPERTY_NUMBER: string;
        const SMS_PROPERTY_PDUTYPE: string;
        const SMS_PROPERTY_SERVICECATEGORY: string;
        const SMS_PROPERTY_SMSC: string;
        const SMS_PROPERTY_STATE: string;
        const SMS_PROPERTY_STORAGE: string;
        const SMS_PROPERTY_TELESERVICEID: string;
        const SMS_PROPERTY_TEXT: string;
        const SMS_PROPERTY_TIMESTAMP: string;
        const SMS_PROPERTY_VALIDITY: string;
        /**
         * Identifier for reporting unknown unlock retries.
         */
        const UNLOCK_RETRIES_UNKNOWN: number;
        /**
         * Gets the nickname string for the #MMBearerAccessTypePreference specified at `val`.
         * @param val a MMBearerAccessTypePreference.
         * @returns a string with the nickname, or %NULL if not found. Do not free the returned value.
         */
        function bearer_access_type_preference_get_string(val: BearerAccessTypePreference | null): string;
        /**
         * Builds a string containing a comma-separated list of nicknames for
         * each #MMBearerAllowedAuth in `mask`.
         * @param mask bitmask of MMBearerAllowedAuth values.
         * @returns a string with the list of nicknames, or %NULL if none given. The returned value should be freed with g_free().
         */
        function bearer_allowed_auth_build_string_from_mask(mask: BearerAllowedAuth | null): string;
        /**
         * Builds a string containing a comma-separated list of nicknames for
         * each #MMBearerApnType in `mask`.
         * @param mask bitmask of MMBearerApnType values.
         * @returns a string with the list of nicknames, or %NULL if none given. The returned value should be freed with g_free().
         */
        function bearer_apn_type_build_string_from_mask(mask: BearerApnType | null): string;
        /**
         * Builds a string containing a comma-separated list of nicknames for
         * each #MMBearerIpFamily in `mask`.
         * @param mask bitmask of MMBearerIpFamily values.
         * @returns a string with the list of nicknames, or %NULL if none given. The returned value should be freed with g_free().
         */
        function bearer_ip_family_build_string_from_mask(mask: BearerIpFamily | null): string;
        /**
         * Gets the nickname string for the #MMBearerIpMethod specified at `val`.
         * @param val a MMBearerIpMethod.
         * @returns a string with the nickname, or %NULL if not found. Do not free the returned value.
         */
        function bearer_ip_method_get_string(val: BearerIpMethod | null): string;
        /**
         * Gets the nickname string for the #MMBearerMultiplexSupport specified at `val`.
         * @param val a MMBearerMultiplexSupport.
         * @returns a string with the nickname, or %NULL if not found. Do not free the returned value.
         */
        function bearer_multiplex_support_get_string(val: BearerMultiplexSupport | null): string;
        /**
         * Gets the nickname string for the #MMBearerProfileSource specified at `val`.
         * @param val a MMBearerProfileSource.
         * @returns a string with the nickname, or %NULL if not found. Do not free the returned value.
         */
        function bearer_profile_source_get_string(val: BearerProfileSource | null): string;
        /**
         * Builds a string containing a comma-separated list of nicknames for
         * each #MMBearerRoamingAllowance in `mask`.
         * @param mask bitmask of MMBearerRoamingAllowance values.
         * @returns a string with the list of nicknames, or %NULL if none given. The returned value should be freed with g_free().
         */
        function bearer_roaming_allowance_build_string_from_mask(mask: BearerRoamingAllowance | null): string;
        /**
         * Gets the nickname string for the #MMBearerType specified at `val`.
         * @param val a MMBearerType.
         * @returns a string with the nickname, or %NULL if not found. Do not free the returned value.
         */
        function bearer_type_get_string(val: BearerType | null): string;
        /**
         * Gets the nickname string for the #MMCallDirection specified at `val`.
         * @param val a MMCallDirection.
         * @returns a string with the nickname, or %NULL if not found. Do not free the returned value.
         */
        function call_direction_get_string(val: CallDirection | null): string;
        /**
         * Gets the nickname string for the #MMCallState specified at `val`.
         * @param val a MMCallState.
         * @returns a string with the nickname, or %NULL if not found. Do not free the returned value.
         */
        function call_state_get_string(val: CallState | null): string;
        /**
         * Gets the nickname string for the #MMCallStateReason specified at `val`.
         * @param val a MMCallStateReason.
         * @returns a string with the nickname, or %NULL if not found. Do not free the returned value.
         */
        function call_state_reason_get_string(val: CallStateReason | null): string;
        function cdma_activation_error_quark(): GLib.Quark;
        /**
         * Gets the nickname string for the #MMCellType specified at `val`.
         * @param val a MMCellType.
         * @returns a string with the nickname, or %NULL if not found. Do not free the returned value.
         */
        function cell_type_get_string(val: CellType | null): string;
        function connection_error_quark(): GLib.Quark;
        function core_error_quark(): GLib.Quark;
        /**
         * Gets the nickname string for the #MMFirmwareImageType specified at `val`.
         * @param val a MMFirmwareImageType.
         * @returns a string with the nickname, or %NULL if not found. Do not free the returned value.
         */
        function firmware_image_type_get_string(val: FirmwareImageType | null): string;
        /**
         * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Bearer.top_of_page">org.freedesktop.ModemManager1.Bearer</link> D-Bus interface.
         * @returns A #GDBusInterfaceInfo. Do not free.
         */
        function gdbus_bearer_interface_info(): Gio.DBusInterfaceInfo;
        /**
         * Overrides all #GObject properties in the #MmGdbusBearer interface for a concrete class.
         * The properties are overridden in the order they are defined.
         * @param klass The class structure for a #GObject derived class.
         * @param property_id_begin The property id to assign to the first overridden property.
         * @returns The last property id.
         */
        function gdbus_bearer_override_properties(klass: typeof GObject.Object, property_id_begin: number): number;
        /**
         * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Call.top_of_page">org.freedesktop.ModemManager1.Call</link> D-Bus interface.
         * @returns A #GDBusInterfaceInfo. Do not free.
         */
        function gdbus_call_interface_info(): Gio.DBusInterfaceInfo;
        /**
         * Overrides all #GObject properties in the #MmGdbusCall interface for a concrete class.
         * The properties are overridden in the order they are defined.
         * @param klass The class structure for a #GObject derived class.
         * @param property_id_begin The property id to assign to the first overridden property.
         * @returns The last property id.
         */
        function gdbus_call_override_properties(klass: typeof GObject.Object, property_id_begin: number): number;
        /**
         * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Modem3gpp.top_of_page">org.freedesktop.ModemManager1.Modem.Modem3gpp</link> D-Bus interface.
         * @returns A #GDBusInterfaceInfo. Do not free.
         */
        function gdbus_modem3gpp_interface_info(): Gio.DBusInterfaceInfo;
        /**
         * Overrides all #GObject properties in the #MmGdbusModem3gpp interface for a concrete class.
         * The properties are overridden in the order they are defined.
         * @param klass The class structure for a #GObject derived class.
         * @param property_id_begin The property id to assign to the first overridden property.
         * @returns The last property id.
         */
        function gdbus_modem3gpp_override_properties(klass: typeof GObject.Object, property_id_begin: number): number;
        /**
         * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.top_of_page">org.freedesktop.ModemManager1.Modem.Modem3gpp.ProfileManager</link> D-Bus interface.
         * @returns A #GDBusInterfaceInfo. Do not free.
         */
        function gdbus_modem3gpp_profile_manager_interface_info(): Gio.DBusInterfaceInfo;
        /**
         * Overrides all #GObject properties in the #MmGdbusModem3gppProfileManager interface for a concrete class.
         * The properties are overridden in the order they are defined.
         * @param klass The class structure for a #GObject derived class.
         * @param property_id_begin The property id to assign to the first overridden property.
         * @returns The last property id.
         */
        function gdbus_modem3gpp_profile_manager_override_properties(
            klass: typeof GObject.Object,
            property_id_begin: number,
        ): number;
        /**
         * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.top_of_page">org.freedesktop.ModemManager1.Modem.Modem3gpp.Ussd</link> D-Bus interface.
         * @returns A #GDBusInterfaceInfo. Do not free.
         */
        function gdbus_modem3gpp_ussd_interface_info(): Gio.DBusInterfaceInfo;
        /**
         * Overrides all #GObject properties in the #MmGdbusModem3gppUssd interface for a concrete class.
         * The properties are overridden in the order they are defined.
         * @param klass The class structure for a #GObject derived class.
         * @param property_id_begin The property id to assign to the first overridden property.
         * @returns The last property id.
         */
        function gdbus_modem3gpp_ussd_override_properties(
            klass: typeof GObject.Object,
            property_id_begin: number,
        ): number;
        /**
         * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-ModemCdma.top_of_page">org.freedesktop.ModemManager1.Modem.ModemCdma</link> D-Bus interface.
         * @returns A #GDBusInterfaceInfo. Do not free.
         */
        function gdbus_modem_cdma_interface_info(): Gio.DBusInterfaceInfo;
        /**
         * Overrides all #GObject properties in the #MmGdbusModemCdma interface for a concrete class.
         * The properties are overridden in the order they are defined.
         * @param klass The class structure for a #GObject derived class.
         * @param property_id_begin The property id to assign to the first overridden property.
         * @returns The last property id.
         */
        function gdbus_modem_cdma_override_properties(klass: typeof GObject.Object, property_id_begin: number): number;
        /**
         * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Firmware.top_of_page">org.freedesktop.ModemManager1.Modem.Firmware</link> D-Bus interface.
         * @returns A #GDBusInterfaceInfo. Do not free.
         */
        function gdbus_modem_firmware_interface_info(): Gio.DBusInterfaceInfo;
        /**
         * Overrides all #GObject properties in the #MmGdbusModemFirmware interface for a concrete class.
         * The properties are overridden in the order they are defined.
         * @param klass The class structure for a #GObject derived class.
         * @param property_id_begin The property id to assign to the first overridden property.
         * @returns The last property id.
         */
        function gdbus_modem_firmware_override_properties(
            klass: typeof GObject.Object,
            property_id_begin: number,
        ): number;
        /**
         * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem.top_of_page">org.freedesktop.ModemManager1.Modem</link> D-Bus interface.
         * @returns A #GDBusInterfaceInfo. Do not free.
         */
        function gdbus_modem_interface_info(): Gio.DBusInterfaceInfo;
        /**
         * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Location.top_of_page">org.freedesktop.ModemManager1.Modem.Location</link> D-Bus interface.
         * @returns A #GDBusInterfaceInfo. Do not free.
         */
        function gdbus_modem_location_interface_info(): Gio.DBusInterfaceInfo;
        /**
         * Overrides all #GObject properties in the #MmGdbusModemLocation interface for a concrete class.
         * The properties are overridden in the order they are defined.
         * @param klass The class structure for a #GObject derived class.
         * @param property_id_begin The property id to assign to the first overridden property.
         * @returns The last property id.
         */
        function gdbus_modem_location_override_properties(
            klass: typeof GObject.Object,
            property_id_begin: number,
        ): number;
        /**
         * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Messaging.top_of_page">org.freedesktop.ModemManager1.Modem.Messaging</link> D-Bus interface.
         * @returns A #GDBusInterfaceInfo. Do not free.
         */
        function gdbus_modem_messaging_interface_info(): Gio.DBusInterfaceInfo;
        /**
         * Overrides all #GObject properties in the #MmGdbusModemMessaging interface for a concrete class.
         * The properties are overridden in the order they are defined.
         * @param klass The class structure for a #GObject derived class.
         * @param property_id_begin The property id to assign to the first overridden property.
         * @returns The last property id.
         */
        function gdbus_modem_messaging_override_properties(
            klass: typeof GObject.Object,
            property_id_begin: number,
        ): number;
        /**
         * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Oma.top_of_page">org.freedesktop.ModemManager1.Modem.Oma</link> D-Bus interface.
         * @returns A #GDBusInterfaceInfo. Do not free.
         */
        function gdbus_modem_oma_interface_info(): Gio.DBusInterfaceInfo;
        /**
         * Overrides all #GObject properties in the #MmGdbusModemOma interface for a concrete class.
         * The properties are overridden in the order they are defined.
         * @param klass The class structure for a #GObject derived class.
         * @param property_id_begin The property id to assign to the first overridden property.
         * @returns The last property id.
         */
        function gdbus_modem_oma_override_properties(klass: typeof GObject.Object, property_id_begin: number): number;
        /**
         * Overrides all #GObject properties in the #MmGdbusModem interface for a concrete class.
         * The properties are overridden in the order they are defined.
         * @param klass The class structure for a #GObject derived class.
         * @param property_id_begin The property id to assign to the first overridden property.
         * @returns The last property id.
         */
        function gdbus_modem_override_properties(klass: typeof GObject.Object, property_id_begin: number): number;
        /**
         * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Sar.top_of_page">org.freedesktop.ModemManager1.Modem.Sar</link> D-Bus interface.
         * @returns A #GDBusInterfaceInfo. Do not free.
         */
        function gdbus_modem_sar_interface_info(): Gio.DBusInterfaceInfo;
        /**
         * Overrides all #GObject properties in the #MmGdbusModemSar interface for a concrete class.
         * The properties are overridden in the order they are defined.
         * @param klass The class structure for a #GObject derived class.
         * @param property_id_begin The property id to assign to the first overridden property.
         * @returns The last property id.
         */
        function gdbus_modem_sar_override_properties(klass: typeof GObject.Object, property_id_begin: number): number;
        /**
         * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Signal.top_of_page">org.freedesktop.ModemManager1.Modem.Signal</link> D-Bus interface.
         * @returns A #GDBusInterfaceInfo. Do not free.
         */
        function gdbus_modem_signal_interface_info(): Gio.DBusInterfaceInfo;
        /**
         * Overrides all #GObject properties in the #MmGdbusModemSignal interface for a concrete class.
         * The properties are overridden in the order they are defined.
         * @param klass The class structure for a #GObject derived class.
         * @param property_id_begin The property id to assign to the first overridden property.
         * @returns The last property id.
         */
        function gdbus_modem_signal_override_properties(
            klass: typeof GObject.Object,
            property_id_begin: number,
        ): number;
        /**
         * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Simple.top_of_page">org.freedesktop.ModemManager1.Modem.Simple</link> D-Bus interface.
         * @returns A #GDBusInterfaceInfo. Do not free.
         */
        function gdbus_modem_simple_interface_info(): Gio.DBusInterfaceInfo;
        /**
         * Overrides all #GObject properties in the #MmGdbusModemSimple interface for a concrete class.
         * The properties are overridden in the order they are defined.
         * @param klass The class structure for a #GObject derived class.
         * @param property_id_begin The property id to assign to the first overridden property.
         * @returns The last property id.
         */
        function gdbus_modem_simple_override_properties(
            klass: typeof GObject.Object,
            property_id_begin: number,
        ): number;
        /**
         * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Time.top_of_page">org.freedesktop.ModemManager1.Modem.Time</link> D-Bus interface.
         * @returns A #GDBusInterfaceInfo. Do not free.
         */
        function gdbus_modem_time_interface_info(): Gio.DBusInterfaceInfo;
        /**
         * Overrides all #GObject properties in the #MmGdbusModemTime interface for a concrete class.
         * The properties are overridden in the order they are defined.
         * @param klass The class structure for a #GObject derived class.
         * @param property_id_begin The property id to assign to the first overridden property.
         * @returns The last property id.
         */
        function gdbus_modem_time_override_properties(klass: typeof GObject.Object, property_id_begin: number): number;
        /**
         * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Voice.top_of_page">org.freedesktop.ModemManager1.Modem.Voice</link> D-Bus interface.
         * @returns A #GDBusInterfaceInfo. Do not free.
         */
        function gdbus_modem_voice_interface_info(): Gio.DBusInterfaceInfo;
        /**
         * Overrides all #GObject properties in the #MmGdbusModemVoice interface for a concrete class.
         * The properties are overridden in the order they are defined.
         * @param klass The class structure for a #GObject derived class.
         * @param property_id_begin The property id to assign to the first overridden property.
         * @returns The last property id.
         */
        function gdbus_modem_voice_override_properties(klass: typeof GObject.Object, property_id_begin: number): number;
        /**
         * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-ModemManager1.top_of_page">org.freedesktop.ModemManager1</link> D-Bus interface.
         * @returns A #GDBusInterfaceInfo. Do not free.
         */
        function gdbus_org_freedesktop_modem_manager1_interface_info(): Gio.DBusInterfaceInfo;
        /**
         * Overrides all #GObject properties in the #MmGdbusOrgFreedesktopModemManager1 interface for a concrete class.
         * The properties are overridden in the order they are defined.
         * @param klass The class structure for a #GObject derived class.
         * @param property_id_begin The property id to assign to the first overridden property.
         * @returns The last property id.
         */
        function gdbus_org_freedesktop_modem_manager1_override_properties(
            klass: typeof GObject.Object,
            property_id_begin: number,
        ): number;
        /**
         * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Sim.top_of_page">org.freedesktop.ModemManager1.Sim</link> D-Bus interface.
         * @returns A #GDBusInterfaceInfo. Do not free.
         */
        function gdbus_sim_interface_info(): Gio.DBusInterfaceInfo;
        /**
         * Overrides all #GObject properties in the #MmGdbusSim interface for a concrete class.
         * The properties are overridden in the order they are defined.
         * @param klass The class structure for a #GObject derived class.
         * @param property_id_begin The property id to assign to the first overridden property.
         * @returns The last property id.
         */
        function gdbus_sim_override_properties(klass: typeof GObject.Object, property_id_begin: number): number;
        /**
         * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Sms.top_of_page">org.freedesktop.ModemManager1.Sms</link> D-Bus interface.
         * @returns A #GDBusInterfaceInfo. Do not free.
         */
        function gdbus_sms_interface_info(): Gio.DBusInterfaceInfo;
        /**
         * Overrides all #GObject properties in the #MmGdbusSms interface for a concrete class.
         * The properties are overridden in the order they are defined.
         * @param klass The class structure for a #GObject derived class.
         * @param property_id_begin The property id to assign to the first overridden property.
         * @returns The last property id.
         */
        function gdbus_sms_override_properties(klass: typeof GObject.Object, property_id_begin: number): number;
        function message_error_quark(): GLib.Quark;
        function mobile_equipment_error_quark(): GLib.Quark;
        /**
         * Gets the nickname string for the #MMModem3gppDrxCycle specified at `val`.
         * @param val a MMModem3gppDrxCycle.
         * @returns a string with the nickname, or %NULL if not found. Do not free the returned value.
         */
        function modem_3gpp_drx_cycle_get_string(val: Modem3gppDrxCycle | null): string;
        /**
         * Gets the nickname string for the #MMModem3gppEpsUeModeOperation specified at `val`.
         * @param val a MMModem3gppEpsUeModeOperation.
         * @returns a string with the nickname, or %NULL if not found. Do not free the returned value.
         */
        function modem_3gpp_eps_ue_mode_operation_get_string(val: Modem3gppEpsUeModeOperation | null): string;
        /**
         * Builds a string containing a comma-separated list of nicknames for
         * each #MMModem3gppFacility in `mask`.
         * @param mask bitmask of MMModem3gppFacility values.
         * @returns a string with the list of nicknames, or %NULL if none given. The returned value should be freed with g_free().
         */
        function modem_3gpp_facility_build_string_from_mask(mask: Modem3gppFacility | null): string;
        /**
         * Gets the nickname string for the #MMModem3gppMicoMode specified at `val`.
         * @param val a MMModem3gppMicoMode.
         * @returns a string with the nickname, or %NULL if not found. Do not free the returned value.
         */
        function modem_3gpp_mico_mode_get_string(val: Modem3gppMicoMode | null): string;
        /**
         * Gets the nickname string for the #MMModem3gppNetworkAvailability specified at `val`.
         * @param val a MMModem3gppNetworkAvailability.
         * @returns a string with the nickname, or %NULL if not found. Do not free the returned value.
         */
        function modem_3gpp_network_availability_get_string(val: Modem3gppNetworkAvailability | null): string;
        /**
         * Gets the nickname string for the #MMModem3gppPacketServiceState specified at `val`.
         * @param val a MMModem3gppPacketServiceState.
         * @returns a string with the nickname, or %NULL if not found. Do not free the returned value.
         */
        function modem_3gpp_packet_service_state_get_string(val: Modem3gppPacketServiceState | null): string;
        /**
         * Gets the nickname string for the #MMModem3gppRegistrationState specified at `val`.
         * @param val a MMModem3gppRegistrationState.
         * @returns a string with the nickname, or %NULL if not found. Do not free the returned value.
         */
        function modem_3gpp_registration_state_get_string(val: Modem3gppRegistrationState | null): string;
        /**
         * Gets the nickname string for the #MMModem3gppSubscriptionState specified at `val`.
         * @param val a MMModem3gppSubscriptionState.
         * @returns a string with the nickname, or %NULL if not found. Do not free the returned value.
         */
        function modem_3gpp_subscription_state_get_string(val: Modem3gppSubscriptionState | null): string;
        /**
         * Gets the nickname string for the #MMModem3gppUssdSessionState specified at `val`.
         * @param val a MMModem3gppUssdSessionState.
         * @returns a string with the nickname, or %NULL if not found. Do not free the returned value.
         */
        function modem_3gpp_ussd_session_state_get_string(val: Modem3gppUssdSessionState | null): string;
        /**
         * Builds a string containing a comma-separated list of nicknames for
         * each #MMModemAccessTechnology in `mask`.
         * @param mask bitmask of MMModemAccessTechnology values.
         * @returns a string with the list of nicknames, or %NULL if none given. The returned value should be freed with g_free().
         */
        function modem_access_technology_build_string_from_mask(mask: ModemAccessTechnology | null): string;
        /**
         * Gets the nickname string for the #MMModemBand specified at `val`.
         * @param val a MMModemBand.
         * @returns a string with the nickname, or %NULL if not found. Do not free the returned value.
         */
        function modem_band_get_string(val: ModemBand | null): string;
        /**
         * Builds a string containing a comma-separated list of nicknames for
         * each #MMModemCapability in `mask`.
         * @param mask bitmask of MMModemCapability values.
         * @returns a string with the list of nicknames, or %NULL if none given. The returned value should be freed with g_free().
         */
        function modem_capability_build_string_from_mask(mask: ModemCapability | null): string;
        /**
         * Gets the nickname string for the #MMModemCdmaActivationState specified at `val`.
         * @param val a MMModemCdmaActivationState.
         * @returns a string with the nickname, or %NULL if not found. Do not free the returned value.
         */
        function modem_cdma_activation_state_get_string(val: ModemCdmaActivationState | null): string;
        /**
         * Gets the nickname string for the #MMModemCdmaRegistrationState specified at `val`.
         * @param val a MMModemCdmaRegistrationState.
         * @returns a string with the nickname, or %NULL if not found. Do not free the returned value.
         */
        function modem_cdma_registration_state_get_string(val: ModemCdmaRegistrationState | null): string;
        /**
         * Gets the nickname string for the #MMModemCdmaRmProtocol specified at `val`.
         * @param val a MMModemCdmaRmProtocol.
         * @returns a string with the nickname, or %NULL if not found. Do not free the returned value.
         */
        function modem_cdma_rm_protocol_get_string(val: ModemCdmaRmProtocol | null): string;
        /**
         * Gets the nickname string for the #MMModemContactsStorage specified at `val`.
         * @param val a MMModemContactsStorage.
         * @returns a string with the nickname, or %NULL if not found. Do not free the returned value.
         */
        function modem_contacts_storage_get_string(val: ModemContactsStorage | null): string;
        /**
         * Builds a string containing a comma-separated list of nicknames for
         * each #MMModemFirmwareUpdateMethod in `mask`.
         * @param mask bitmask of MMModemFirmwareUpdateMethod values.
         * @returns a string with the list of nicknames, or %NULL if none given. The returned value should be freed with g_free().
         */
        function modem_firmware_update_method_build_string_from_mask(mask: ModemFirmwareUpdateMethod | null): string;
        /**
         * Builds a string containing a comma-separated list of nicknames for
         * each #MMModemLocationAssistanceDataType in `mask`.
         * @param mask bitmask of MMModemLocationAssistanceDataType values.
         * @returns a string with the list of nicknames, or %NULL if none given. The returned value should be freed with g_free().
         */
        function modem_location_assistance_data_type_build_string_from_mask(
            mask: ModemLocationAssistanceDataType | null,
        ): string;
        /**
         * Builds a string containing a comma-separated list of nicknames for
         * each #MMModemLocationSource in `mask`.
         * @param mask bitmask of MMModemLocationSource values.
         * @returns a string with the list of nicknames, or %NULL if none given. The returned value should be freed with g_free().
         */
        function modem_location_source_build_string_from_mask(mask: ModemLocationSource | null): string;
        /**
         * Gets the nickname string for the #MMModemLock specified at `val`.
         * @param val a MMModemLock.
         * @returns a string with the nickname, or %NULL if not found. Do not free the returned value.
         */
        function modem_lock_get_string(val: ModemLock | null): string;
        /**
         * Builds a string containing a comma-separated list of nicknames for
         * each #MMModemMode in `mask`.
         * @param mask bitmask of MMModemMode values.
         * @returns a string with the list of nicknames, or %NULL if none given. The returned value should be freed with g_free().
         */
        function modem_mode_build_string_from_mask(mask: ModemMode | null): string;
        /**
         * Gets the nickname string for the #MMModemPortType specified at `val`.
         * @param val a MMModemPortType.
         * @returns a string with the nickname, or %NULL if not found. Do not free the returned value.
         */
        function modem_port_type_get_string(val: ModemPortType | null): string;
        /**
         * Gets the nickname string for the #MMModemPowerState specified at `val`.
         * @param val a MMModemPowerState.
         * @returns a string with the nickname, or %NULL if not found. Do not free the returned value.
         */
        function modem_power_state_get_string(val: ModemPowerState | null): string;
        /**
         * Gets the nickname string for the #MMModemStateChangeReason specified at `val`.
         * @param val a MMModemStateChangeReason.
         * @returns a string with the nickname, or %NULL if not found. Do not free the returned value.
         */
        function modem_state_change_reason_get_string(val: ModemStateChangeReason | null): string;
        /**
         * Gets the nickname string for the #MMModemStateFailedReason specified at `val`.
         * @param val a MMModemStateFailedReason.
         * @returns a string with the nickname, or %NULL if not found. Do not free the returned value.
         */
        function modem_state_failed_reason_get_string(val: ModemStateFailedReason | null): string;
        /**
         * Gets the nickname string for the #MMModemState specified at `val`.
         * @param val a MMModemState.
         * @returns a string with the nickname, or %NULL if not found. Do not free the returned value.
         */
        function modem_state_get_string(val: ModemState | null): string;
        /**
         * Builds a string containing a comma-separated list of nicknames for
         * each #MMOmaFeature in `mask`.
         * @param mask bitmask of MMOmaFeature values.
         * @returns a string with the list of nicknames, or %NULL if none given. The returned value should be freed with g_free().
         */
        function oma_feature_build_string_from_mask(mask: OmaFeature | null): string;
        /**
         * Gets the nickname string for the #MMOmaSessionStateFailedReason specified at `val`.
         * @param val a MMOmaSessionStateFailedReason.
         * @returns a string with the nickname, or %NULL if not found. Do not free the returned value.
         */
        function oma_session_state_failed_reason_get_string(val: OmaSessionStateFailedReason | null): string;
        /**
         * Gets the nickname string for the #MMOmaSessionState specified at `val`.
         * @param val a MMOmaSessionState.
         * @returns a string with the nickname, or %NULL if not found. Do not free the returned value.
         */
        function oma_session_state_get_string(val: OmaSessionState | null): string;
        /**
         * Gets the nickname string for the #MMOmaSessionType specified at `val`.
         * @param val a MMOmaSessionType.
         * @returns a string with the nickname, or %NULL if not found. Do not free the returned value.
         */
        function oma_session_type_get_string(val: OmaSessionType | null): string;
        function serial_error_quark(): GLib.Quark;
        /**
         * Gets the nickname string for the #MMServingCellType specified at `val`.
         * @param val a MMServingCellType.
         * @returns a string with the nickname, or %NULL if not found. Do not free the returned value.
         */
        function serving_cell_type_get_string(val: ServingCellType | null): string;
        /**
         * Gets the nickname string for the #MMSimEsimStatus specified at `val`.
         * @param val a MMSimEsimStatus.
         * @returns a string with the nickname, or %NULL if not found. Do not free the returned value.
         */
        function sim_esim_status_get_string(val: SimEsimStatus | null): string;
        /**
         * Gets the nickname string for the #MMSimRemovability specified at `val`.
         * @param val a MMSimRemovability.
         * @returns a string with the nickname, or %NULL if not found. Do not free the returned value.
         */
        function sim_removability_get_string(val: SimRemovability | null): string;
        /**
         * Gets the nickname string for the #MMSimType specified at `val`.
         * @param val a MMSimType.
         * @returns a string with the nickname, or %NULL if not found. Do not free the returned value.
         */
        function sim_type_get_string(val: SimType | null): string;
        /**
         * Gets the nickname string for the #MMSmsCdmaServiceCategory specified at `val`.
         * @param val a MMSmsCdmaServiceCategory.
         * @returns a string with the nickname, or %NULL if not found. Do not free the returned value.
         */
        function sms_cdma_service_category_get_string(val: SmsCdmaServiceCategory | null): string;
        /**
         * Gets the nickname string for the #MMSmsCdmaTeleserviceId specified at `val`.
         * @param val a MMSmsCdmaTeleserviceId.
         * @returns a string with the nickname, or %NULL if not found. Do not free the returned value.
         */
        function sms_cdma_teleservice_id_get_string(val: SmsCdmaTeleserviceId | null): string;
        /**
         * Gets the nickname string for the #MMSmsDeliveryState specified at `val`.
         * @param val a MMSmsDeliveryState.
         * @returns a string with the nickname, or %NULL if not found. Do not free the returned value.
         */
        function sms_delivery_state_get_string(val: SmsDeliveryState | null): string;
        /**
         * Gets the nickname string for the #MMSmsPduType specified at `val`.
         * @param val a MMSmsPduType.
         * @returns a string with the nickname, or %NULL if not found. Do not free the returned value.
         */
        function sms_pdu_type_get_string(val: SmsPduType | null): string;
        /**
         * Gets the nickname string for the #MMSmsState specified at `val`.
         * @param val a MMSmsState.
         * @returns a string with the nickname, or %NULL if not found. Do not free the returned value.
         */
        function sms_state_get_string(val: SmsState | null): string;
        /**
         * Gets the nickname string for the #MMSmsStorage specified at `val`.
         * @param val a MMSmsStorage.
         * @returns a string with the nickname, or %NULL if not found. Do not free the returned value.
         */
        function sms_storage_get_string(val: SmsStorage | null): string;
        /**
         * Gets the nickname string for the #MMSmsValidityType specified at `val`.
         * @param val a MMSmsValidityType.
         * @returns a string with the nickname, or %NULL if not found. Do not free the returned value.
         */
        function sms_validity_type_get_string(val: SmsValidityType | null): string;
        interface UnlockRetriesForeachCb {
            (lock: ModemLock, count: number): void;
        }

        export namespace __3gppProfileCmpFlags {
            export const $gtype: GObject.GType<__3gppProfileCmpFlags>;
        }

        enum __3gppProfileCmpFlags {
            NONE,
            NO_PROFILE_ID,
            NO_PROFILE_NAME,
            NO_AUTH,
            NO_APN_TYPE,
            NO_IP_TYPE,
            NO_ACCESS_TYPE_PREFERENCE,
            NO_ENABLED,
            NO_ROAMING_ALLOWANCE,
            NO_PROFILE_SOURCE,
        }

        export namespace BearerAllowedAuth {
            export const $gtype: GObject.GType<BearerAllowedAuth>;
        }

        enum BearerAllowedAuth {
            UNKNOWN,
            NONE,
            PAP,
            CHAP,
            MSCHAP,
            MSCHAPV2,
            EAP,
        }

        export namespace BearerApnType {
            export const $gtype: GObject.GType<BearerApnType>;
        }

        enum BearerApnType {
            NONE,
            INITIAL,
            DEFAULT,
            IMS,
            MMS,
            MANAGEMENT,
            VOICE,
            EMERGENCY,
            PRIVATE,
            PURCHASE,
            VIDEO_SHARE,
            LOCAL,
            APP,
            XCAP,
            TETHERING,
        }

        export namespace BearerIpFamily {
            export const $gtype: GObject.GType<BearerIpFamily>;
        }

        enum BearerIpFamily {
            NONE,
            IPV4,
            IPV6,
            IPV4V6,
            NON_IP,
            ANY,
        }

        export namespace BearerPropertiesCmpFlags {
            export const $gtype: GObject.GType<BearerPropertiesCmpFlags>;
        }

        enum BearerPropertiesCmpFlags {
            NONE,
            LOOSE,
            NO_PASSWORD,
            NO_ALLOW_ROAMING,
            NO_RM_PROTOCOL,
            NO_APN_TYPE,
            NO_PROFILE_ID,
            NO_PROFILE_NAME,
            NO_ACCESS_TYPE_PREFERENCE,
            NO_ROAMING_ALLOWANCE,
        }

        export namespace BearerRoamingAllowance {
            export const $gtype: GObject.GType<BearerRoamingAllowance>;
        }

        enum BearerRoamingAllowance {
            NONE,
            HOME,
            PARTNER,
            NON_PARTNER,
        }

        export namespace Modem3gppFacility {
            export const $gtype: GObject.GType<Modem3gppFacility>;
        }

        enum Modem3gppFacility {
            NONE,
            SIM,
            FIXED_DIALING,
            PH_SIM,
            PH_FSIM,
            NET_PERS,
            NET_SUB_PERS,
            PROVIDER_PERS,
            CORP_PERS,
        }

        export namespace ModemAccessTechnology {
            export const $gtype: GObject.GType<ModemAccessTechnology>;
        }

        enum ModemAccessTechnology {
            UNKNOWN,
            POTS,
            GSM,
            GSM_COMPACT,
            GPRS,
            EDGE,
            UMTS,
            HSDPA,
            HSUPA,
            HSPA,
            HSPA_PLUS,
            '1XRTT',
            EVDO0,
            EVDOA,
            EVDOB,
            LTE,
            '5GNR',
            LTE_CAT_M,
            LTE_NB_IOT,
            ANY,
        }

        export namespace ModemCapability {
            export const $gtype: GObject.GType<ModemCapability>;
        }

        enum ModemCapability {
            NONE,
            POTS,
            CDMA_EVDO,
            GSM_UMTS,
            LTE,
            IRIDIUM,
            '5GNR',
            TDS,
            ANY,
        }

        export namespace ModemFirmwareUpdateMethod {
            export const $gtype: GObject.GType<ModemFirmwareUpdateMethod>;
        }

        enum ModemFirmwareUpdateMethod {
            NONE,
            FASTBOOT,
            QMI_PDC,
            MBIM_QDU,
            FIREHOSE,
            SAHARA,
        }

        export namespace ModemLocationAssistanceDataType {
            export const $gtype: GObject.GType<ModemLocationAssistanceDataType>;
        }

        enum ModemLocationAssistanceDataType {
            NONE,
            XTRA,
        }

        export namespace ModemLocationSource {
            export const $gtype: GObject.GType<ModemLocationSource>;
        }

        enum ModemLocationSource {
            NONE,
            '3GPP_LAC_CI',
            GPS_RAW,
            GPS_NMEA,
            CDMA_BS,
            GPS_UNMANAGED,
            AGPS_MSA,
            AGPS_MSB,
        }

        export namespace ModemMode {
            export const $gtype: GObject.GType<ModemMode>;
        }

        enum ModemMode {
            NONE,
            CS,
            '2G',
            '3G',
            '4G',
            '5G',
            ANY,
        }

        export namespace OmaFeature {
            export const $gtype: GObject.GType<OmaFeature>;
        }

        enum OmaFeature {
            NONE,
            DEVICE_PROVISIONING,
            PRL_UPDATE,
            HANDS_FREE_ACTIVATION,
        }
        namespace __3gppProfile {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {}
        }

        /**
         * The #MM3gppProfile structure contains private data and should
         * only be accessed using the provided API.
         */
        class __3gppProfile extends GObject.Object {
            static $gtype: GObject.GType<__3gppProfile>;

            // Constructors

            constructor(properties?: Partial<__3gppProfile.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static ['new'](): __3gppProfile;

            // Methods

            consume_string(key: string, value: string): boolean;
            consume_variant(key: string, value: GLib.Variant): boolean;
            /**
             * Gets 5G network access type preference.
             * @returns a #MMBearerAccessTypePreference.
             */
            get_access_type_preference(): BearerAccessTypePreference;
            /**
             * Gets the methods allowed to use when authenticating with the access point.
             * @returns a bitmask of #MMBearerAllowedAuth values, or %MM_BEARER_ALLOWED_AUTH_UNKNOWN to request the modem-default method.
             */
            get_allowed_auth(): BearerAllowedAuth;
            /**
             * Gets the name of the access point.
             * @returns the access point, or #NULL if not set. Do not free the returned value, it is owned by @self.
             */
            get_apn(): string;
            /**
             * Gets the APN types to use.
             * @returns a mask of #MMBearerApnType values.
             */
            get_apn_type(): BearerApnType;
            /**
             * Checks whether the profile is enabled or disabled.
             * @returns %TRUE if the profile is enabled, %FALSE otherwise.
             */
            get_enabled(): boolean;
            /**
             * Gets the IP type to use.
             * @returns a #MMBearerIpFamily.
             */
            get_ip_type(): BearerIpFamily;
            /**
             * Gets the password used to authenticate with the access point.
             * @returns the password, or #NULL if not set. Do not free the returned value, it is owned by @self.
             */
            get_password(): string;
            /**
             * Gets the profile id.
             * @returns the profile id..
             */
            get_profile_id(): number;
            /**
             * Gets the name of the profile.
             * @returns the profile name, or #NULL if not set. Do not free the returned value, it is owned by @self.
             */
            get_profile_name(): string;
            /**
             * Gets the profile source.
             * @returns a #MMBearerProfileSource.
             */
            get_profile_source(): BearerProfileSource;
            /**
             * Gets the roaming allowance rules.
             * @returns a mask of #MMBearerRoamingAllowance values.
             */
            get_roaming_allowance(): BearerRoamingAllowance;
            /**
             * Gets the username used to authenticate with the access point.
             * @returns the username, or #NULL if not set. Do not free the returned value, it is owned by @self.
             */
            get_user(): string;
            /**
             * Sets the 5G network access type preference.
             * @param access_type_preference a #MMBearerAccessTypePreference.
             */
            set_access_type_preference(access_type_preference: BearerAccessTypePreference | null): void;
            /**
             * Sets the method to use when authenticating with the access point.
             * @param allowed_auth a bitmask of #MMBearerAllowedAuth values.  %MM_BEARER_ALLOWED_AUTH_UNKNOWN may be given to request the modem-default  method.
             */
            set_allowed_auth(allowed_auth: BearerAllowedAuth | null): void;
            /**
             * Sets the name of the access point to use.
             * @param apn Name of the access point.
             */
            set_apn(apn: string): void;
            /**
             * Sets the APN types to use.
             * @param apn_type a mask of #MMBearerApnType values.
             */
            set_apn_type(apn_type: BearerApnType | null): void;
            /**
             * Sets the flag to indicate whether the profile is enabled or disabled.
             * @param enabled boolean value.
             */
            set_enabled(enabled: boolean): void;
            /**
             * Sets the IP type to use.
             * @param ip_type a #MMBearerIpFamily.
             */
            set_ip_type(ip_type: BearerIpFamily | null): void;
            /**
             * Sets the password used to authenticate with the access point.
             * @param password the password
             */
            set_password(password: string): void;
            /**
             * Sets the profile id to use.
             *
             * If none specified explicitly, #MM_3GPP_PROFILE_ID_UNKNOWN is assumed.
             * @param profile_id Numeric profile id to use, or #MM_3GPP_PROFILE_ID_UNKNOWN.
             */
            set_profile_id(profile_id: number): void;
            /**
             * Sets the name of the profile.
             * @param profile_name Name of the profile.
             */
            set_profile_name(profile_name: string): void;
            /**
             * Sets profile source.
             * @param profile_source a #MMBearerProfileSource.
             */
            set_profile_source(profile_source: BearerProfileSource | null): void;
            /**
             * Sets the roaming allowance rules.
             * @param roaming_allowance a mask of #MMBearerRoamingAllowance values.
             */
            set_roaming_allowance(roaming_allowance: BearerRoamingAllowance | null): void;
            /**
             * Sets the username used to authenticate with the access point.
             * @param user the username
             */
            set_user(user: string): void;
        }

        namespace Bearer {
            // Constructor properties interface

            interface ConstructorProps
                extends GdbusBearerProxy.ConstructorProps,
                    Gio.AsyncInitable.ConstructorProps,
                    Gio.DBusInterface.ConstructorProps,
                    Gio.Initable.ConstructorProps,
                    GdbusBearer.ConstructorProps {}
        }

        /**
         * The #MMBearer structure contains private data and should only be accessed
         * using the provided API.
         */
        class Bearer
            extends GdbusBearerProxy
            implements Gio.AsyncInitable<Bearer>, Gio.DBusInterface, Gio.Initable, GdbusBearer
        {
            static $gtype: GObject.GType<Bearer>;

            // Constructors

            constructor(properties?: Partial<Bearer.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Methods

            /**
             * Asynchronously requests activation of a packet data connection with the
             * network using this #MMBearer properties.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_bearer_connect_finish() to get the result of the operation.
             *
             * See mm_bearer_connect_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            connect(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously requests activation of a packet data connection with the
             * network using this #MMBearer properties.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_bearer_connect_finish() to get the result of the operation.
             *
             * See mm_bearer_connect_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            connect(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously requests activation of a packet data connection with the
             * network using this #MMBearer properties.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_bearer_connect_finish() to get the result of the operation.
             *
             * See mm_bearer_connect_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            connect(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            connect(...args: never[]): any;
            /**
             * Finishes an operation started with mm_bearer_connect().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_bearer_connect().
             * @returns %TRUE if the operation succeeded, %FALSE if @error is set.
             */
            connect_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously requests activation of a packet data connection with the
             * network using this #MMBearer properties.
             *
             * The calling thread is blocked until a reply is received.
             * See mm_bearer_connect() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the operation succeeded, %FALSE if @error is set.
             */
            connect_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Synchronously requests disconnection and deactivation of the packet data
             * connection.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_bearer_disconnect_finish() to get the result of the operation.
             *
             * See mm_bearer_disconnect_sync() for the synchronous, blocking version of this
             * method.
             * @param cancellable A #GCancellable or %NULL.
             */
            disconnect(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Synchronously requests disconnection and deactivation of the packet data
             * connection.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_bearer_disconnect_finish() to get the result of the operation.
             *
             * See mm_bearer_disconnect_sync() for the synchronous, blocking version of this
             * method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            disconnect(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Synchronously requests disconnection and deactivation of the packet data
             * connection.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_bearer_disconnect_finish() to get the result of the operation.
             *
             * See mm_bearer_disconnect_sync() for the synchronous, blocking version of this
             * method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            disconnect(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            // Conflicted with GObject.Object.disconnect
            disconnect(...args: never[]): any;
            /**
             * Finishes an operation started with mm_bearer_disconnect().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_bearer_disconnect().
             * @returns %TRUE if the operation succeeded, %FALSE if @error is set.
             */
            disconnect_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously requests disconnection and deactivation of the packet data
             * connection.
             *
             * The calling thread is blocked until a reply is received.
             * See mm_bearer_disconnect() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the operation succeeded, %FALSE if @error is set.
             */
            disconnect_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Gets a copy of the operating system name for the network data interface that
             * provides packet data using this #MMBearer. This will only be available once
             * the #MMBearer is in connected state.
             * @returns The name of the interface, or %NULL if it couldn't be retrieved. The returned value should be freed with g_free().
             */
            dup_interface(): string;
            /**
             * Gets a copy of the DBus path of the #MMBearer object.
             * @returns The DBus path of the #MMBearer object. The returned value should be freed with g_free().
             */
            dup_path(): string;
            /**
             * Gets the type of bearer.
             * @returns a #MMBearerType.
             */
            get_bearer_type(): BearerType;
            /**
             * Checks whether or not the #MMBearer is connected and thus whether packet data
             * communication is possible.
             * @returns %TRUE if the #MMBearer is connected, #FALSE otherwise.
             */
            get_connected(): boolean;
            /**
             * Gets a #GError specifying the connection error details, if any.
             *
             * <warning>The values reported by `self` are not updated when the values in the
             * interface change. Instead, the client is expected to call
             * mm_bearer_get_connection_error() again to get a new #GError with the
             * new values.</warning>
             * @returns A #GError that must be freed with g_error_free() or %NULL if none.
             */
            get_connection_error(): GLib.Error;
            /**
             * Gets the operating system name for the network data interface that provides
             * packet data using this #MMBearer. This will only be available once the #MMBearer
             * is in connected state.
             *
             * <warning>The returned value is only valid until the property changes so
             * it is only safe to use this function on the thread where
             * `self` was constructed. Use mm_bearer_dup_interface() if on another
             * thread.</warning>
             * @returns The name of the interface, or %NULL if it couldn't be retrieved.
             */
            get_interface(): string;
            /**
             * Gets the maximum time to wait for the bearer to retrieve a valid IP address.
             * @returns The IP timeout, or 0 if no specific one given.
             */
            get_ip_timeout(): number;
            /**
             * Gets a #MMBearerIpConfig object specifying the IPv4 configuration to use in
             * the bearer.
             *
             * <warning>The values reported by `self` are not updated when the values in the
             * interface change. Instead, the client is expected to call
             * mm_bearer_get_ipv4_config() again to get a new #MMBearerIpConfig with the
             * new values.</warning>
             * @returns A #MMBearerIpConfig that must be freed with g_object_unref() or %NULL if unknown.
             */
            get_ipv4_config(): BearerIpConfig;
            /**
             * Gets a #MMBearerIpConfig object specifying the IPv6 configuration to use in
             * the bearer.
             *
             * <warning>The values reported by `self` are not updated when the values in the
             * interface change. Instead, the client is expected to call
             * mm_bearer_get_ipv6_config() again to get a new #MMBearerIpConfig with the
             * new values.</warning>
             * @returns A #MMBearerIpConfig that must be freed with g_object_unref() or %NULL if unknown.
             */
            get_ipv6_config(): BearerIpConfig;
            /**
             * Checks whether or not the #MMBearer is connected through a multiplexed
             * network likn.
             * @returns %TRUE if packet data service is connected via a multiplexed network link in the #MMBearer, #FALSE otherwise.
             */
            get_multiplexed(): boolean;
            /**
             * Gets the DBus path of the #MMBearer object.
             * @returns The DBus path of the #MMBearer object.
             */
            get_path(): string;
            /**
             * Gets profile ID associated to the bearer connection, if known.
             *
             * If the bearer is disconnected or the modem doesn't support profile management
             * features, %MM_3GPP_PROFILE_ID_UNKNOWN.
             * @returns a profile id.
             */
            get_profile_id(): number;
            /**
             * Gets a #MMBearerProperties object specifying the properties which were used
             * to create the bearer.
             *
             * <warning>The values reported by `self` are not updated when the values in the
             * interface change. Instead, the client is expected to call
             * mm_bearer_get_properties() again to get a new #MMBearerProperties with the
             * new values.</warning>
             * @returns A #MMBearerProperties that must be freed with g_object_unref() or %NULL if unknown.
             */
            get_properties(): BearerProperties;
            /**
             * Checks whether or not the #MMBearer supporting stats reload (to have
             * RX and TX bytes of the ongoing connection).
             * @returns %TRUE if the #MMBearer supports these stats, #FALSE otherwise.
             */
            get_reload_stats_supported(): boolean;
            /**
             * Gets a #MMBearerStats object specifying the statistics of the current bearer
             * connection.
             *
             * <warning>The values reported by `self` are not updated when the values in the
             * interface change. Instead, the client is expected to call
             * mm_bearer_get_stats() again to get a new #MMBearerStats with the
             * new values.</warning>
             * @returns A #MMBearerStats that must be freed with g_object_unref() or %NULL if unknown.
             */
            get_stats(): BearerStats;
            /**
             * Checks whether or not the #MMBearer is suspended (but not deactivated) while
             * the device is handling other communications, like a voice call.
             * @returns %TRUE if packet data service is suspended in the #MMBearer, #FALSE otherwise.
             */
            get_suspended(): boolean;
            /**
             * Gets a #GError specifying the connection error details, if any.
             *
             * <warning>The returned value is only valid until the property changes so
             * it is only safe to use this function on the thread where
             * `self` was constructed. Use mm_bearer_get_connection_error() if on another
             * thread.</warning>
             * @returns A #GError, or %NULL if none. Do not free the returned value, it belongs to @self.
             */
            peek_connection_error(): GLib.Error;
            /**
             * Gets a #MMBearerIpConfig object specifying the IPv4 configuration to use in
             * the bearer.
             *
             * <warning>The returned value is only valid until the property changes so
             * it is only safe to use this function on the thread where
             * `self` was constructed. Use mm_bearer_get_ipv4_config() if on another
             * thread.</warning>
             * @returns A #MMBearerIpConfig. Do not free the returned value, it belongs to @self.
             */
            peek_ipv4_config(): BearerIpConfig;
            /**
             * Gets a #MMBearerIpConfig object specifying the IPv6 configuration to use in
             * the bearer.
             *
             * <warning>The returned value is only valid until the property changes so
             * it is only safe to use this function on the thread where
             * `self` was constructed. Use mm_bearer_get_ipv6_config() if on another
             * thread.</warning>
             * @returns A #MMBearerIpConfig. Do not free the returned value, it belongs to @self.
             */
            peek_ipv6_config(): BearerIpConfig;
            /**
             * Gets a #MMBearerProperties object specifying the properties which were used
             * to create the bearer.
             *
             * <warning>The returned value is only valid until the property changes so
             * it is only safe to use this function on the thread where
             * `self` was constructed. Use mm_bearer_get_properties() if on another
             * thread.</warning>
             * @returns A #MMBearerProperties. Do not free the returned value, it belongs to @self.
             */
            peek_properties(): BearerProperties;
            /**
             * Gets a #MMBearerStats object specifying the statistics of the current bearer
             * connection.
             *
             * <warning>The returned value is only valid until the property changes so
             * it is only safe to use this function on the thread where
             * `self` was constructed. Use mm_bearer_get_stats() if on another
             * thread.</warning>
             * @returns A #MMBearerStats. Do not free the returned value, it belongs to @self.
             */
            peek_stats(): BearerStats;

            // Inherited properties
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.BearerType">"BearerType"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get bearer_type(): number;
            set bearer_type(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.BearerType">"BearerType"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get bearerType(): number;
            set bearerType(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.Connected">"Connected"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get connected(): boolean;
            set connected(val: boolean);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.ConnectionError">"ConnectionError"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get connection_error(): GLib.Variant;
            set connection_error(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.ConnectionError">"ConnectionError"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get connectionError(): GLib.Variant;
            set connectionError(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.Interface">"Interface"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get interface(): string;
            set interface(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.IpTimeout">"IpTimeout"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get ip_timeout(): number;
            set ip_timeout(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.IpTimeout">"IpTimeout"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get ipTimeout(): number;
            set ipTimeout(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.Ip4Config">"Ip4Config"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get ip4_config(): GLib.Variant;
            set ip4_config(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.Ip4Config">"Ip4Config"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get ip4Config(): GLib.Variant;
            set ip4Config(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.Ip6Config">"Ip6Config"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get ip6_config(): GLib.Variant;
            set ip6_config(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.Ip6Config">"Ip6Config"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get ip6Config(): GLib.Variant;
            set ip6Config(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.Multiplexed">"Multiplexed"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get multiplexed(): boolean;
            set multiplexed(val: boolean);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.ProfileId">"ProfileId"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get profile_id(): number;
            set profile_id(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.ProfileId">"ProfileId"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get profileId(): number;
            set profileId(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.Properties">"Properties"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get properties(): GLib.Variant;
            set properties(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.ReloadStatsSupported">"ReloadStatsSupported"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get reload_stats_supported(): boolean;
            set reload_stats_supported(val: boolean);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.ReloadStatsSupported">"ReloadStatsSupported"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get reloadStatsSupported(): boolean;
            set reloadStatsSupported(val: boolean);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.Stats">"Stats"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get stats(): GLib.Variant;
            set stats(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.Suspended">"Suspended"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get suspended(): boolean;
            set suspended(val: boolean);

            // Inherited methods
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            init_async(io_priority: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             * @returns %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present.
             */
            init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Finishes the async construction for the various g_async_initable_new
             * calls, returning the created object or %NULL on error.
             * @param res the #GAsyncResult from the callback
             * @returns a newly created #GObject,      or %NULL on error. Free with g_object_unref().
             */
            new_finish(res: Gio.AsyncResult): Bearer;
            // Conflicted with ModemManager.GdbusBearerProxy.new_finish
            new_finish(...args: never[]): any;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            vfunc_init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             */
            vfunc_init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Bearer.Connect">Connect()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_bearer_call_connect_finish() to get the result of the operation.
             *
             * See mm_gdbus_bearer_call_connect_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_connect(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Bearer.Connect">Connect()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_bearer_call_connect_finish() to get the result of the operation.
             *
             * See mm_gdbus_bearer_call_connect_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_connect(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Bearer.Connect">Connect()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_bearer_call_connect_finish() to get the result of the operation.
             *
             * See mm_gdbus_bearer_call_connect_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_connect(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_bearer_call_connect().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_bearer_call_connect().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_connect_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Bearer.Connect">Connect()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_bearer_call_connect() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_connect_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Bearer.Disconnect">Disconnect()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_bearer_call_disconnect_finish() to get the result of the operation.
             *
             * See mm_gdbus_bearer_call_disconnect_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_disconnect(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Bearer.Disconnect">Disconnect()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_bearer_call_disconnect_finish() to get the result of the operation.
             *
             * See mm_gdbus_bearer_call_disconnect_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_disconnect(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Bearer.Disconnect">Disconnect()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_bearer_call_disconnect_finish() to get the result of the operation.
             *
             * See mm_gdbus_bearer_call_disconnect_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_disconnect(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_bearer_call_disconnect().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_bearer_call_disconnect().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_disconnect_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Bearer.Disconnect">Disconnect()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_bearer_call_disconnect() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_disconnect_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Bearer.Connect">Connect()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_connect(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Bearer.Disconnect">Disconnect()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_disconnect(invocation: Gio.DBusMethodInvocation): void;
            vfunc_handle_connect(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_disconnect(invocation: Gio.DBusMethodInvocation): boolean;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace BearerIpConfig {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {}
        }

        /**
         * The #MMBearerIpConfig structure contains private data and should
         * only be accessed using the provided API.
         */
        class BearerIpConfig extends GObject.Object {
            static $gtype: GObject.GType<BearerIpConfig>;

            // Constructors

            constructor(properties?: Partial<BearerIpConfig.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Methods

            /**
             * Gets the IP address to be used with this bearer.
             * @returns a string with the IP address, or #NULL if unknown. Do not free the returned value, it is owned by @self.
             */
            get_address(): string;
            /**
             * Gets the list of IP addresses of DNS servers to be used with this bearer.
             * @returns a %NULL-terminated array of strings. Do not free the returned value, it is owned by @self.
             */
            get_dns(): string[];
            /**
             * Gets the IP address of the gateway to be used with this bearer.
             * @returns a string with the IP address, or #NULL if unknown. Do not free the returned value, it is owned by @self.
             */
            get_gateway(): string;
            /**
             * Gets the IP method to be used with this bearer.
             * @returns a #MMBearerIpMethod.
             */
            get_method(): BearerIpMethod;
            /**
             * Gets the MTU to be used with this bearer.
             * @returns the MTU.
             */
            get_mtu(): number;
            /**
             * Gets the network prefix to be used with this bearer.
             * @returns the network prefix.
             */
            get_prefix(): number;
        }

        namespace BearerProperties {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {}
        }

        /**
         * The #MMBearerProperties structure contains private data and should
         * only be accessed using the provided API.
         */
        class BearerProperties extends GObject.Object {
            static $gtype: GObject.GType<BearerProperties>;

            // Constructors

            constructor(properties?: Partial<BearerProperties.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static ['new'](): BearerProperties;

            // Methods

            /**
             * Gets the 5G network access type preference.
             * @returns a #MMBearerAccessTypePreference value.
             */
            get_access_type_preference(): BearerAccessTypePreference;
            /**
             * Checks whether roaming is allowed in the connection.
             * @returns %TRUE if roaming is allowed, %FALSE otherwise.
             */
            get_allow_roaming(): boolean;
            /**
             * Gets the authentication methods allowed in the connection.
             * @returns a bitmask of #MMBearerAllowedAuth values, or %MM_BEARER_ALLOWED_AUTH_UNKNOWN to request the modem-default method.
             */
            get_allowed_auth(): BearerAllowedAuth;
            /**
             * Gets the name of the access point to use when connecting.
             * @returns the access point, or #NULL if not set. Do not free the returned value, it is owned by @self.
             */
            get_apn(): string;
            /**
             * Gets the APN types to use.
             * @returns a mask of #MMBearerApnType values.
             */
            get_apn_type(): BearerApnType;
            /**
             * Sets the IP type to use.
             * @returns a #MMBearerIpFamily.
             */
            get_ip_type(): BearerIpFamily;
            /**
             * Gets the type of multiplex support requested by the user.
             * @returns a #MMBearerMultiplexSupport.
             */
            get_multiplex(): BearerMultiplexSupport;
            /**
             * Gets the number to use when performing the connection.
             * @returns the number, or #NULL if not set. Do not free the returned value, it is owned by @self.
             */
            get_number(): string;
            /**
             * Gets the password used to authenticate with the access point.
             * @returns the password, or #NULL if not set. Do not free the returned value, it is owned by @self.
             */
            get_password(): string;
            /**
             * Gets the profile ID to use.
             * @returns the profile id.
             */
            get_profile_id(): number;
            /**
             * Gets the name of the profile to use when connecting.
             * @returns the profile name, or #NULL if not set. Do not free the returned value, it is owned by @self.
             */
            get_profile_name(): string;
            /**
             * Gets the RM protocol requested to use in the CDMA connection.
             * @returns a #MMModemCdmaRmProtocol.
             */
            get_rm_protocol(): ModemCdmaRmProtocol;
            /**
             * Gets the roaming allowance rules.
             * @returns a mask of #MMBearerRoamingAllowance values.
             */
            get_roaming_allowance(): BearerRoamingAllowance;
            /**
             * Gets the username used to authenticate with the access point.
             * @returns the username, or #NULL if not set. Do not free the returned value, it is owned by @self.
             */
            get_user(): string;
            /**
             * Sets the 5G network access type preference.
             * @param access_type_preference a #MMBearerAccessTypePreference value.
             */
            set_access_type_preference(access_type_preference: BearerAccessTypePreference | null): void;
            /**
             * Sets the flag to indicate whether roaming is allowed or not in the
             * connection.
             * @param allow_roaming boolean value.
             */
            set_allow_roaming(allow_roaming: boolean): void;
            /**
             * Sets the authentication method to use.
             * @param allowed_auth a bitmask of #MMBearerAllowedAuth values.  %MM_BEARER_ALLOWED_AUTH_UNKNOWN may be given to request the modem-default  method.
             */
            set_allowed_auth(allowed_auth: BearerAllowedAuth | null): void;
            /**
             * Sets the name of the access point to use when connecting.
             * @param apn Name of the access point.
             */
            set_apn(apn: string): void;
            /**
             * Sets the APN types to use.
             * @param apn_type a mask of #MMBearerApnType values.
             */
            set_apn_type(apn_type: BearerApnType | null): void;
            /**
             * Sets the IP type to use.
             * @param ip_type a #MMBearerIpFamily.
             */
            set_ip_type(ip_type: BearerIpFamily | null): void;
            /**
             * Gets the type of multiplex support requested by the user.
             * @param multiplex a #MMBearerMultiplexSupport.
             */
            set_multiplex(multiplex: BearerMultiplexSupport | null): void;
            /**
             * Sets the number to use when performing the connection.
             * @param number the number.
             */
            set_number(number: string): void;
            /**
             * Sets the password used to authenticate with the access point.
             * @param password the password
             */
            set_password(password: string): void;
            /**
             * Sets the profile ID to use.
             * @param profile_id a profile id.
             */
            set_profile_id(profile_id: number): void;
            /**
             * Sets the name of the profile to use when connecting.
             * @param profile_name Name of the profile.
             */
            set_profile_name(profile_name: string): void;
            /**
             * Sets the RM protocol to use in the CDMA connection.
             * @param protocol a #MMModemCdmaRmProtocol.
             */
            set_rm_protocol(protocol: ModemCdmaRmProtocol | null): void;
            /**
             * Sets the roaming allowance rules.
             * @param roaming_allowance a mask of #MMBearerRoamingAllowance values
             */
            set_roaming_allowance(roaming_allowance: BearerRoamingAllowance | null): void;
            /**
             * Sets the username used to authenticate with the access point.
             * @param user the username
             */
            set_user(user: string): void;
        }

        namespace BearerStats {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {}
        }

        /**
         * The #MMBearerStats structure contains private data and should
         * only be accessed using the provided API.
         */
        class BearerStats extends GObject.Object {
            static $gtype: GObject.GType<BearerStats>;

            // Constructors

            constructor(properties?: Partial<BearerStats.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Methods

            /**
             * Gets the number of connection attempts done with this bearer.
             * @returns a #guint.
             */
            get_attempts(): number;
            /**
             * Gets the speed of the downlink, in bits per second.
             * @returns a #guint64.
             */
            get_downlink_speed(): number;
            /**
             * Gets the duration of the current connection, in seconds.
             * @returns a #guint.
             */
            get_duration(): number;
            /**
             * Gets the number of failed connection attempts done with this bearer.
             * @returns a #guint.
             */
            get_failed_attempts(): number;
            /**
             * Gets the number of bytes received without error in the connection.
             * @returns a #guint64.
             */
            get_rx_bytes(): number;
            /**
             * Gets the start date of the current connection as a timestamp in seconds
             * since the epoch.
             * @returns a #guint64.
             */
            get_start_date(): number;
            /**
             * Gets the total duration of all the connections of this bearer.
             * @returns a #guint.
             */
            get_total_duration(): number;
            /**
             * Gets the total number of bytes received without error during all the
             * connections of this bearer.
             * @returns a #guint64.
             */
            get_total_rx_bytes(): number;
            /**
             * Gets the total number of bytes transmitted without error during all the
             * connections of this bearer.
             * @returns a #guint64.
             */
            get_total_tx_bytes(): number;
            /**
             * Gets the number of bytes transmitted without error in the connection.
             * @returns a #guint64.
             */
            get_tx_bytes(): number;
            /**
             * Gets the speed of the uplink, in bits per second.
             * @returns a #guint64.
             */
            get_uplink_speed(): number;
        }

        namespace Call {
            // Constructor properties interface

            interface ConstructorProps
                extends GdbusCallProxy.ConstructorProps,
                    Gio.AsyncInitable.ConstructorProps,
                    Gio.DBusInterface.ConstructorProps,
                    Gio.Initable.ConstructorProps,
                    GdbusCall.ConstructorProps {}
        }

        /**
         * The #MMCall structure contains private data and should only be accessed
         * using the provided API.
         */
        class Call
            extends GdbusCallProxy
            implements Gio.AsyncInitable<Call>, Gio.DBusInterface, Gio.Initable, GdbusCall
        {
            static $gtype: GObject.GType<Call>;

            // Constructors

            constructor(properties?: Partial<Call.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Methods

            /**
             * Asynchronously requests to accept the incoming call.
             *
             * Call objects can only be executed once.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_call_accept_finish() to get the result of the operation.
             *
             * See mm_call_accept_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            accept(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously requests to accept the incoming call.
             *
             * Call objects can only be executed once.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_call_accept_finish() to get the result of the operation.
             *
             * See mm_call_accept_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            accept(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously requests to accept the incoming call.
             *
             * Call objects can only be executed once.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_call_accept_finish() to get the result of the operation.
             *
             * See mm_call_accept_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            accept(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_call_accept().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_call_accept().
             * @returns %TRUE if the operation succeeded, %FALSE if @error is set.
             */
            accept_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously requests to accept the incoming call.
             *
             * Call objects can only be sent once.
             *
             * The calling thread is blocked until an incoming call is ready.
             * See mm_call_accept() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the operation succeeded, %FALSE if @error is set.
             */
            accept_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously requests to deflect the incoming call.
             *
             * This call will be considered terminated once the deflection is performed.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_call_deflect_finish() to get the result of the operation.
             *
             * See mm_call_deflect_sync() for the synchronous, blocking version of this
             * method.
             * @param number new number where the call will be deflected.
             * @param cancellable A #GCancellable or %NULL.
             */
            deflect(number: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously requests to deflect the incoming call.
             *
             * This call will be considered terminated once the deflection is performed.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_call_deflect_finish() to get the result of the operation.
             *
             * See mm_call_deflect_sync() for the synchronous, blocking version of this
             * method.
             * @param number new number where the call will be deflected.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            deflect(
                number: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously requests to deflect the incoming call.
             *
             * This call will be considered terminated once the deflection is performed.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_call_deflect_finish() to get the result of the operation.
             *
             * See mm_call_deflect_sync() for the synchronous, blocking version of this
             * method.
             * @param number new number where the call will be deflected.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            deflect(
                number: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_call_deflect().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_call_deflect().
             * @returns %TRUE if the operation succeeded, %FALSE if @error is set.
             */
            deflect_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously requests to deflect the incoming call.
             *
             * This call will be considered terminated once the deflection is performed.
             *
             * The calling thread is blocked until an incoming call is ready.
             * See mm_call_deflect() for the asynchronous version of this method.
             * @param number new number where the call will be deflected.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the operation succeeded, %FALSE if @error is set.
             */
            deflect_sync(number: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Gets the kernel device used for audio (if any).
             * @returns The audio port, or %NULL if call audio is not routed via the host or couldn't be retrieved.
             */
            dup_audio_port(): string;
            /**
             * Gets the call number. In outgoing calls contains the dialing number or
             * the remote number in incoming calls
             * @returns The number, or %NULL if it couldn't be retrieved. The returned value should be freed with g_free().
             */
            dup_number(): string;
            /**
             * Gets a copy of the DBus path of the #MMCall object.
             * @returns The DBus path of the #MMCall object. The returned value should be freed with g_free().
             */
            dup_path(): string;
            /**
             * Gets a #MMCallAudioFormat object specifying the audio format used by the
             * audio port if call audio is routed via the host.
             *
             * <warning>The values reported by `self` are not updated when the values in the
             * interface change. Instead, the client is expected to call
             * mm_call_get_audio_format() again to get a new #MMCallAudioFormat with the
             * new values.</warning>
             * @returns A #MMCallAudioFormat that must be freed with g_object_unref() or %NULL if unknown.
             */
            get_audio_format(): CallAudioFormat;
            /**
             * Gets the kernel device used for audio (if any).
             * @returns The audio port, or %NULL if call audio is not routed via the host or couldn't be retrieved.
             */
            get_audio_port(): string;
            /**
             * Gets the call direction.
             * @returns a #MMCallDirection.
             */
            get_direction(): CallDirection;
            /**
             * Gets whether the call is part of a multiparty call.
             * @returns %TRUE if the call is part of a multiparty call, %FALSE otherwise.
             */
            get_multiparty(): boolean;
            /**
             * Gets the call number. In outgoing calls contains the dialing number or
             * the remote number in incoming calls
             *
             * <warning>The returned value is only valid until the property changes so
             * it is only safe to use this function on the thread where
             * `self` was constructed. Use mm_call_dup_number() if on another
             * thread.</warning>
             * @returns The number, or %NULL if it couldn't be retrieved.
             */
            get_number(): string;
            /**
             * Gets the DBus path of the #MMCall object.
             * @returns The DBus path of the #MMCall object.
             */
            get_path(): string;
            /**
             * Gets the current state of call.
             * @returns a #MMCallState.
             */
            get_state(): CallState;
            /**
             * Gets the reason of why the call changes its state.
             * @returns a #MMCallStateReason.
             */
            get_state_reason(): CallStateReason;
            /**
             * Asynchronously requests to hangup the call.
             *
             * Call objects can only be executed once.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_call_hangup_finish() to get the result of the operation.
             *
             * See mm_call_hangup_sync() for the synchronous, blocking version of this
             * method.
             * @param cancellable A #GCancellable or %NULL.
             */
            hangup(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously requests to hangup the call.
             *
             * Call objects can only be executed once.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_call_hangup_finish() to get the result of the operation.
             *
             * See mm_call_hangup_sync() for the synchronous, blocking version of this
             * method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            hangup(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously requests to hangup the call.
             *
             * Call objects can only be executed once.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_call_hangup_finish() to get the result of the operation.
             *
             * See mm_call_hangup_sync() for the synchronous, blocking version of this
             * method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            hangup(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_call_hangup().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_call_hangup().
             * @returns %TRUE if the operation succeeded, %FALSE if @error is set.
             */
            hangup_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously requests to hangup the call.
             *
             * Call objects can only be sent once.
             *
             * The calling thread is blocked until an incoming call is ready.
             * See mm_call_hangup() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the operation succeeded, %FALSE if @error is set.
             */
            hangup_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Synchronously requests to join this call into a multiparty call.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_call_join_multiparty_finish() to get the result of the operation.
             *
             * See mm_call_join_multiparty_sync() for the synchronous, blocking version of
             * this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            join_multiparty(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Synchronously requests to join this call into a multiparty call.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_call_join_multiparty_finish() to get the result of the operation.
             *
             * See mm_call_join_multiparty_sync() for the synchronous, blocking version of
             * this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            join_multiparty(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Synchronously requests to join this call into a multiparty call.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_call_join_multiparty_finish() to get the result of the operation.
             *
             * See mm_call_join_multiparty_sync() for the synchronous, blocking version of
             * this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            join_multiparty(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_call_join_multiparty().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_call_join_multiparty().
             * @returns %TRUE if the operation succeeded, %FALSE if @error is set.
             */
            join_multiparty_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously requests to join this call into a multiparty call.
             *
             * The calling thread is blocked until an incoming call is ready.
             * See mm_call_join_multiparty() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the operation succeeded, %FALSE if @error is set.
             */
            join_multiparty_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Synchronously requests to make this call private again by leaving the
             * multiparty call.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_call_leave_multiparty_finish() to get the result of the operation.
             *
             * See mm_call_leave_multiparty_sync() for the synchronous, blocking version
             * of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            leave_multiparty(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Synchronously requests to make this call private again by leaving the
             * multiparty call.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_call_leave_multiparty_finish() to get the result of the operation.
             *
             * See mm_call_leave_multiparty_sync() for the synchronous, blocking version
             * of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            leave_multiparty(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Synchronously requests to make this call private again by leaving the
             * multiparty call.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_call_leave_multiparty_finish() to get the result of the operation.
             *
             * See mm_call_leave_multiparty_sync() for the synchronous, blocking version
             * of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            leave_multiparty(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_call_leave_multiparty().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_call_leave_multiparty().
             * @returns %TRUE if the operation succeeded, %FALSE if @error is set.
             */
            leave_multiparty_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously requests to make this call private again by leaving the
             * multiparty call.
             *
             * The calling thread is blocked until an incoming call is ready.
             * See mm_call_leave_multiparty() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the operation succeeded, %FALSE if @error is set.
             */
            leave_multiparty_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Gets a #MMCallAudioFormat object specifying the audio format used by the
             * audio port if call audio is routed via the host.
             *
             * <warning>The returned value is only valid until the property changes so
             * it is only safe to use this function on the thread where
             * `self` was constructed. Use mm_call_get_audio_format() if on another
             * thread.</warning>
             * @returns A #MMCallAudioFormat. Do not free the returned value, it belongs to @self.
             */
            peek_audio_format(): CallAudioFormat;
            /**
             * Asynchronously requests to send a DTMF tone the call.
             *
             * Call objects can only be executed once.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_call_send_dtmf_finish() to get the result of the operation.
             *
             * See mm_call_send_dtmf_sync() for the synchronous, blocking version of this
             * method.
             * @param dtmf the DMTF tone.
             * @param cancellable A #GCancellable or %NULL.
             */
            send_dtmf(dtmf: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously requests to send a DTMF tone the call.
             *
             * Call objects can only be executed once.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_call_send_dtmf_finish() to get the result of the operation.
             *
             * See mm_call_send_dtmf_sync() for the synchronous, blocking version of this
             * method.
             * @param dtmf the DMTF tone.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            send_dtmf(
                dtmf: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously requests to send a DTMF tone the call.
             *
             * Call objects can only be executed once.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_call_send_dtmf_finish() to get the result of the operation.
             *
             * See mm_call_send_dtmf_sync() for the synchronous, blocking version of this
             * method.
             * @param dtmf the DMTF tone.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            send_dtmf(
                dtmf: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_call_send_dtmf().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_call_send_dtmf().
             * @returns %TRUE if the operation succeeded, %FALSE if @error is set.
             */
            send_dtmf_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously requests to send a DTMF tone the call.
             *
             * Call objects can only be sent once.
             *
             * The calling thread is blocked until an incoming call is ready.
             * See mm_call_send_dtmf() for the asynchronous version of this method.
             * @param dtmf the DMTF tone.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the operation succeeded, %FALSE if @error is set.
             */
            send_dtmf_sync(dtmf: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously requests to queue the call.
             *
             * Call objects can only be executed once.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_call_start_finish() to get the result of the operation.
             *
             * See mm_call_start_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            start(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously requests to queue the call.
             *
             * Call objects can only be executed once.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_call_start_finish() to get the result of the operation.
             *
             * See mm_call_start_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            start(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously requests to queue the call.
             *
             * Call objects can only be executed once.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_call_start_finish() to get the result of the operation.
             *
             * See mm_call_start_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            start(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_call_start().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_call_start().
             * @returns %TRUE if the operation succeeded, %FALSE if @error is set.
             */
            start_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously requests to queue the call for delivery.
             *
             * Call objects can only be sent once.
             *
             * The calling thread is blocked until a reply is received.
             * See mm_call_start() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the operation succeeded, %FALSE if @error is set.
             */
            start_sync(cancellable?: Gio.Cancellable | null): boolean;

            // Inherited properties
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Call.AudioFormat">"AudioFormat"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get audio_format(): GLib.Variant;
            set audio_format(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Call.AudioFormat">"AudioFormat"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get audioFormat(): GLib.Variant;
            set audioFormat(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Call.AudioPort">"AudioPort"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get audio_port(): string;
            set audio_port(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Call.AudioPort">"AudioPort"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get audioPort(): string;
            set audioPort(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Call.Direction">"Direction"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get direction(): number;
            set direction(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Call.Multiparty">"Multiparty"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get multiparty(): boolean;
            set multiparty(val: boolean);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Call.Number">"Number"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get number(): string;
            set number(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Call.State">"State"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get state(): number;
            set state(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Call.StateReason">"StateReason"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get state_reason(): number;
            set state_reason(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Call.StateReason">"StateReason"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get stateReason(): number;
            set stateReason(val: number);

            // Inherited methods
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            init_async(io_priority: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             * @returns %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present.
             */
            init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Finishes the async construction for the various g_async_initable_new
             * calls, returning the created object or %NULL on error.
             * @param res the #GAsyncResult from the callback
             * @returns a newly created #GObject,      or %NULL on error. Free with g_object_unref().
             */
            new_finish(res: Gio.AsyncResult): Call;
            // Conflicted with ModemManager.GdbusCallProxy.new_finish
            new_finish(...args: never[]): any;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            vfunc_init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             */
            vfunc_init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Accept">Accept()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_accept_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_accept_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_accept(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Accept">Accept()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_accept_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_accept_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_accept(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Accept">Accept()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_accept_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_accept_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_accept(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_call_call_accept().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_call_call_accept().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_accept_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Accept">Accept()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_call_call_accept() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_accept_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Deflect">Deflect()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_deflect_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_deflect_sync() for the synchronous, blocking version of this method.
             * @param arg_number Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_deflect(arg_number: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Deflect">Deflect()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_deflect_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_deflect_sync() for the synchronous, blocking version of this method.
             * @param arg_number Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_deflect(
                arg_number: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Deflect">Deflect()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_deflect_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_deflect_sync() for the synchronous, blocking version of this method.
             * @param arg_number Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_deflect(
                arg_number: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_call_call_deflect().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_call_call_deflect().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_deflect_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Deflect">Deflect()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_call_call_deflect() for the asynchronous version of this method.
             * @param arg_number Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_deflect_sync(arg_number: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Hangup">Hangup()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_hangup_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_hangup_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_hangup(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Hangup">Hangup()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_hangup_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_hangup_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_hangup(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Hangup">Hangup()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_hangup_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_hangup_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_hangup(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_call_call_hangup().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_call_call_hangup().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_hangup_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Hangup">Hangup()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_call_call_hangup() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_hangup_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.JoinMultiparty">JoinMultiparty()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_join_multiparty_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_join_multiparty_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_join_multiparty(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.JoinMultiparty">JoinMultiparty()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_join_multiparty_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_join_multiparty_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_join_multiparty(
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.JoinMultiparty">JoinMultiparty()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_join_multiparty_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_join_multiparty_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_join_multiparty(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_call_call_join_multiparty().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_call_call_join_multiparty().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_join_multiparty_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.JoinMultiparty">JoinMultiparty()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_call_call_join_multiparty() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_join_multiparty_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.LeaveMultiparty">LeaveMultiparty()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_leave_multiparty_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_leave_multiparty_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_leave_multiparty(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.LeaveMultiparty">LeaveMultiparty()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_leave_multiparty_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_leave_multiparty_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_leave_multiparty(
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.LeaveMultiparty">LeaveMultiparty()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_leave_multiparty_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_leave_multiparty_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_leave_multiparty(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_call_call_leave_multiparty().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_call_call_leave_multiparty().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_leave_multiparty_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.LeaveMultiparty">LeaveMultiparty()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_call_call_leave_multiparty() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_leave_multiparty_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.SendDtmf">SendDtmf()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_send_dtmf_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_send_dtmf_sync() for the synchronous, blocking version of this method.
             * @param arg_dtmf Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_send_dtmf(arg_dtmf: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.SendDtmf">SendDtmf()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_send_dtmf_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_send_dtmf_sync() for the synchronous, blocking version of this method.
             * @param arg_dtmf Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_send_dtmf(
                arg_dtmf: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.SendDtmf">SendDtmf()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_send_dtmf_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_send_dtmf_sync() for the synchronous, blocking version of this method.
             * @param arg_dtmf Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_send_dtmf(
                arg_dtmf: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_call_call_send_dtmf().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_call_call_send_dtmf().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_send_dtmf_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.SendDtmf">SendDtmf()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_call_call_send_dtmf() for the asynchronous version of this method.
             * @param arg_dtmf Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_send_dtmf_sync(arg_dtmf: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Start">Start()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_start_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_start_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_start(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Start">Start()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_start_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_start_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_start(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Start">Start()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_start_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_start_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_start(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_call_call_start().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_call_call_start().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_start_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Start">Start()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_call_call_start() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_start_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Accept">Accept()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_accept(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Deflect">Deflect()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_deflect(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Hangup">Hangup()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_hangup(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.JoinMultiparty">JoinMultiparty()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_join_multiparty(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.LeaveMultiparty">LeaveMultiparty()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_leave_multiparty(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.SendDtmf">SendDtmf()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_send_dtmf(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Start">Start()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_start(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Emits the <link linkend="gdbus-signal-org-freedesktop-ModemManager1-Call.DtmfReceived">"DtmfReceived"</link> D-Bus signal.
             * @param arg_dtmf Argument to pass with the signal.
             */
            emit_dtmf_received(arg_dtmf: string): void;
            /**
             * Emits the <link linkend="gdbus-signal-org-freedesktop-ModemManager1-Call.StateChanged">"StateChanged"</link> D-Bus signal.
             * @param arg_old Argument to pass with the signal.
             * @param arg_new Argument to pass with the signal.
             * @param arg_reason Argument to pass with the signal.
             */
            emit_state_changed(arg_old: number, arg_new: number, arg_reason: number): void;
            vfunc_dtmf_received(arg_dtmf: string): void;
            vfunc_handle_accept(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_deflect(invocation: Gio.DBusMethodInvocation, arg_number: string): boolean;
            vfunc_handle_hangup(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_join_multiparty(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_leave_multiparty(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_send_dtmf(invocation: Gio.DBusMethodInvocation, arg_dtmf: string): boolean;
            vfunc_handle_start(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_state_changed(arg_old: number, arg_new: number, arg_reason: number): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace CallAudioFormat {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {}
        }

        /**
         * The #MMCallAudioFormat structure contains private data and should
         * only be accessed using the provided API.
         */
        class CallAudioFormat extends GObject.Object {
            static $gtype: GObject.GType<CallAudioFormat>;

            // Constructors

            constructor(properties?: Partial<CallAudioFormat.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Methods

            /**
             * Gets the encoding of the audio format.  For example, "pcm" for PCM-encoded
             * audio.
             * @returns a string with the encoding, or #NULL if unknown. Do not free the returned value, it is owned by @self.
             */
            get_encoding(): string;
            /**
             * Gets the sampling rate of the audio format.  For example, 8000 for an 8000hz
             * sampling rate.
             * @returns the sampling rate, or 0 if unknown.
             */
            get_rate(): number;
            /**
             * Gets the resolution of the audio format.  For example, "s16le" for signed
             * 16-bit little-endian audio sampling resolution.
             * @returns a string with the resolution, or #NULL if unknown. Do not free the returned value, it is owned by @self.
             */
            get_resolution(): string;
        }

        namespace CallProperties {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {}
        }

        /**
         * The #MMCallProperties structure contains private data and should only be
         * accessed using the provided API.
         */
        class CallProperties extends GObject.Object {
            static $gtype: GObject.GType<CallProperties>;

            // Constructors

            constructor(properties?: Partial<CallProperties.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static ['new'](): CallProperties;

            static new_from_dictionary(dictionary: GLib.Variant): CallProperties;

            static new_from_string(str: string): CallProperties;

            // Methods

            get_dictionary(): GLib.Variant;
            /**
             * Gets the call direction.
             * @returns the call direction.
             */
            get_direction(): CallDirection;
            /**
             * Gets the number, in UTF-8.
             * @returns the call number, or %NULL if it doesn't contain any (anonymous caller). Do not free the returned value, it is owned by @self.
             */
            get_number(): string;
            /**
             * Gets the call state.
             * @returns the call state.
             */
            get_state(): CallState;
            /**
             * Gets the call state reason.
             * @returns the call state reason.
             */
            get_state_reason(): CallStateReason;
            /**
             * Sets the call direction.
             * @param direction the call direction
             */
            set_direction(direction: CallDirection | null): void;
            /**
             * Sets the call number.
             * @param text The number to set, in UTF-8.
             */
            set_number(text: string): void;
            /**
             * Sets the call state
             * @param state the call state
             */
            set_state(state: CallState | null): void;
            /**
             * Sets the call state reason.
             * @param state_reason the call state reason.
             */
            set_state_reason(state_reason: CallStateReason | null): void;
        }

        namespace CdmaManualActivationProperties {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {}
        }

        /**
         * The #MMCdmaManualActivationProperties structure contains private data and should only be accessed
         * using the provided API.
         */
        class CdmaManualActivationProperties extends GObject.Object {
            static $gtype: GObject.GType<CdmaManualActivationProperties>;

            // Constructors

            constructor(properties?: Partial<CdmaManualActivationProperties.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static ['new'](): CdmaManualActivationProperties;

            // Methods

            /**
             * Gets the Mobile Directory Number.
             * @returns The MDN. Do not free the returned value, it is owned by @self.
             */
            get_mdn(): string;
            /**
             * Gets the Mobile Indentification Number.
             * @returns The MIN. Do not free the returned value, it is owned by @self.
             */
            get_min(): string;
            /**
             * Gets the MN-AAA key.
             * @returns The MN-AAA key. Do not free the returned value, it is owned by @self.
             */
            get_mn_aaa_key(): string;
            /**
             * Gets the MN-HA key.
             * @returns The MN-HA key. Do not free the returned value, it is owned by @self.
             */
            get_mn_ha_key(): string;
            /**
             * Gets the Preferred Roaming List.
             * @returns The PRL. Do not free the returned value, it is owned by @self.
             */
            get_prl(): [number, number];
            /**
             * Gets the Preferred Roaming List.
             * @returns A #GByteArray with the PRL, or %NULL if it doesn't contain any. The returned value should be freed with g_byte_array_unref().
             */
            get_prl_bytearray(): Uint8Array;
            /**
             * Gets the System Identification Number.
             * @returns The SID.
             */
            get_sid(): number;
            /**
             * Gets the Service Programming Code.
             * @returns The SPC. Do not free the returned value, it is owned by @self.
             */
            get_spc(): string;
            /**
             * Gets the Preferred Roaming List.
             * @returns A #GByteArray with the PRL, or %NULL if it doesn't contain any. Do not free the returned value, it is owned by @self.
             */
            peek_prl_bytearray(): Uint8Array;
            /**
             * Sets the Mobile Directory Number.
             * @param mdn The MDN string, maximum 15 characters.
             * @returns %TRUE if the MDN was successfully set, or %FALSE if @error is set.
             */
            set_mdn(mdn: string): boolean;
            /**
             * Sets the Mobile Identification Number.
             * @param min The MIN string, maximum 15 characters.
             * @returns %TRUE if the MIN was successfully set, or %FALSE if @error is set.
             */
            set_min(min: string): boolean;
            /**
             * Sets the Mobile Identification Number.
             * @param mn_aaa_key The MN-AAA key string, maximum 16 characters.
             * @returns %TRUE if the MN-AAA key was successfully set, or %FALSE if @error is set.
             */
            set_mn_aaa_key(mn_aaa_key: string): boolean;
            /**
             * Sets the Mobile Identification Number.
             * @param mn_ha_key The MN-HA key string, maximum 16 characters.
             * @returns %TRUE if the MN-HA key was successfully set, or %FALSE if @error is set.
             */
            set_mn_ha_key(mn_ha_key: string): boolean;
            /**
             * Sets the Preferred Roaming List.
             * @param prl The PRL.
             * @param prl_length Length of @prl.
             * @returns %TRUE if the PRL was successfully set, or %FALSE if @error is set.
             */
            set_prl(prl: number, prl_length: number): boolean;
            /**
             * Sets the Preferred Roaming List.
             * @param prl A #GByteArray with the PRL to set. This method takes a new reference  of @prl.
             * @returns %TRUE if the PRL was successfully set, or %FALSE if @error is set.
             */
            set_prl_bytearray(prl: Uint8Array | string): boolean;
            /**
             * Sets the Service Identification Number.
             * @param sid The SID.
             */
            set_sid(sid: number): void;
            /**
             * Sets the Service Programming Code.
             * @param spc The SPC string, exactly 6 digits.
             * @returns %TRUE if the SPC was successfully set, or %FALSE if @error is set.
             */
            set_spc(spc: string): boolean;
        }

        namespace CellInfo {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {}
        }

        /**
         * The #MMCellInfo structure contains private data and should only be
         * accessed using the provided API.
         */
        class CellInfo extends GObject.Object {
            static $gtype: GObject.GType<CellInfo>;

            // Constructors

            constructor(properties?: Partial<CellInfo.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Virtual methods

            vfunc_build_string(): GLib.String;
            vfunc_get_dictionary(): GLib.VariantDict;

            // Methods

            /**
             * Get the type of cell.
             * @returns a #MMCellType.
             */
            get_cell_type(): CellType;
            /**
             * Get whether the cell is a serving cell or a neighboring cell.a
             * @returns %TRUE if the cell is a serving cell, %FALSE otherwise.
             */
            get_serving(): boolean;
        }

        namespace CellInfoCdma {
            // Constructor properties interface

            interface ConstructorProps extends CellInfo.ConstructorProps {}
        }

        /**
         * The #MMCellInfoCdma structure contains private data and should only be
         * accessed using the provided API.
         */
        class CellInfoCdma extends CellInfo {
            static $gtype: GObject.GType<CellInfoCdma>;

            // Constructors

            constructor(properties?: Partial<CellInfoCdma.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Methods

            /**
             * Get the CDMA base station id.
             *
             * Encoded in upper-case hexadecimal format without leading zeros.
             * @returns the CDMA base station id, or %NULL if not available.
             */
            get_base_station_id(): string;
            /**
             * Get the CDMA network id.
             *
             * Encoded in upper-case hexadecimal format without leading zeros.
             * @returns the CDMA network id, or %NULL if not available.
             */
            get_nid(): string;
            /**
             * Get the signal strength of the pilot.
             *
             * Given in the same format and scale as the GSM SINR level.
             * @returns the pilot strength, or %G_MAXUINT if not available.
             */
            get_pilot_strength(): number;
            /**
             * Get the CDMA base station PN number.
             *
             * Encoded in upper-case hexadecimal format without leading zeros.
             * @returns the CDMA base station PN number, or %NULL if not available.
             */
            get_ref_pn(): string;
            /**
             * Get the CDMA system id.
             *
             * Encoded in upper-case hexadecimal format without leading zeros.
             * @returns the CDMA system id, or %NULL if not available.
             */
            get_sid(): string;
        }

        namespace CellInfoGsm {
            // Constructor properties interface

            interface ConstructorProps extends CellInfo.ConstructorProps {}
        }

        /**
         * The #MMCellInfoGsm structure contains private data and should only be
         * accessed using the provided API.
         */
        class CellInfoGsm extends CellInfo {
            static $gtype: GObject.GType<CellInfoGsm>;

            // Constructors

            constructor(properties?: Partial<CellInfoGsm.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Methods

            /**
             * Get the absolute RF channel number.
             * @returns the ARFCN, or %G_MAXUINT if not available.
             */
            get_arfcn(): number;
            /**
             * Get the GSM base station id, in upper-case hexadecimal format without leading
             * zeros. E.g. "3F".
             * @returns the GSM base station id, or %NULL if not available.
             */
            get_base_station_id(): string;
            /**
             * Get the two- or four-byte Cell Identifier.
             *
             * Encoded in upper-case hexadecimal format without leading zeros,
             * as specified in 3GPP TS 27.007.
             * @returns the MCCMNC, or %NULL if not available.
             */
            get_ci(): string;
            /**
             * Get the two-byte Location Area Code of the base station.
             *
             * Encoded in upper-case hexadecimal format without leading zeros,
             * as specified in 3GPP TS 27.007.
             * @returns the MCCMNC, or %NULL if not available.
             */
            get_lac(): string;
            /**
             * Get the PLMN MCC/MNC.
             * @returns the MCCMNC, or %NULL if not available.
             */
            get_operator_id(): string;
            /**
             * Get the serving cell RX measurement.
             * @returns the rx level, or %G_MAXUINT if not available.
             */
            get_rx_level(): number;
            /**
             * Get the measured delay (in bit periods) of an access burst transmission
             * on the RACH or PRACH to the expected signal from a mobile station at zero
             * distance under static channel conditions.
             * @returns the timing advance, or %G_MAXUINT if not available.
             */
            get_timing_advance(): number;
        }

        namespace CellInfoLte {
            // Constructor properties interface

            interface ConstructorProps extends CellInfo.ConstructorProps {}
        }

        /**
         * The #MMCellInfoLte structure contains private data and should only be
         * accessed using the provided API.
         */
        class CellInfoLte extends CellInfo {
            static $gtype: GObject.GType<CellInfoLte>;

            // Constructors

            constructor(properties?: Partial<CellInfoLte.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Methods

            /**
             * Get the bandwidth of the particular carrier in downlink.
             * @returns the bandwidth, or %G_MAXUINT if not available.
             */
            get_bandwidth(): number;
            /**
             * Get the two- or four-byte Cell Identifier.
             *
             * Encoded in upper-case hexadecimal format without leading zeros,
             * as specified in 3GPP TS 27.007.
             * @returns the MCCMNC, or %NULL if not available.
             */
            get_ci(): string;
            /**
             * Get the E-UTRA absolute RF channel number.
             * @returns the EARFCN, or %G_MAXUINT if not available.
             */
            get_earfcn(): number;
            /**
             * Get the PLMN MCC/MNC.
             * @returns the MCCMNC, or %NULL if not available.
             */
            get_operator_id(): string;
            /**
             * Get the physical cell identifier.
             *
             * Encoded in upper-case hexadecimal format without leading zeros,
             * as specified in 3GPP TS 27.007.
             * @returns the MCCMNC, or %NULL if not available.
             */
            get_physical_ci(): string;
            /**
             * Get the average reference signal received power in dBm.
             * @returns the RSRP, or -%G_MAXDOUBLE if not available.
             */
            get_rsrp(): number;
            /**
             * Get the average reference signal received quality in dB.
             * @returns the RSRQ, or -%G_MAXDOUBLE if not available.
             */
            get_rsrq(): number;
            /**
             * Get the serving cell type.
             * @returns the serving cell type, or %MM_SERVING_CELL_TYPE_INVALID if not available.
             */
            get_serving_cell_type(): ServingCellType;
            /**
             * Get the two- or three- byte Tracking Area Code of the base station.
             *
             * Encoded in upper-case hexadecimal format without leading zeros,
             * as specified in 3GPP TS 27.007.
             * @returns the MCCMNC, or %NULL if not available.
             */
            get_tac(): string;
            /**
             * Get the timing advance.
             * @returns the timing advance, or %G_MAXUINT if not available.
             */
            get_timing_advance(): number;
        }

        namespace CellInfoNr5g {
            // Constructor properties interface

            interface ConstructorProps extends CellInfo.ConstructorProps {}
        }

        /**
         * The #MMCellInfoNr5g structure contains private data and should only be
         * accessed using the provided API.
         */
        class CellInfoNr5g extends CellInfo {
            static $gtype: GObject.GType<CellInfoNr5g>;

            // Constructors

            constructor(properties?: Partial<CellInfoNr5g.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Methods

            /**
             * Get the bandwidth of the particular carrier in downlink.
             * @returns the bandwidth, or %G_MAXUINT if not available.
             */
            get_bandwidth(): number;
            /**
             * Get the two- or four-byte Cell Identifier.
             *
             * Encoded in upper-case hexadecimal format without leading zeros,
             * as specified in 3GPP TS 27.007.
             * @returns the MCCMNC, or %NULL if not available.
             */
            get_ci(): string;
            /**
             * Get the NR absolute RF channel number.
             * @returns the NRARFCN, or %G_MAXUINT if not available.
             */
            get_nrarfcn(): number;
            /**
             * Get the PLMN MCC/MNC.
             * @returns the MCCMNC, or %NULL if not available.
             */
            get_operator_id(): string;
            /**
             * Get the physical cell identifier.
             *
             * Encoded in upper-case hexadecimal format without leading zeros,
             * as specified in 3GPP TS 27.007.
             * @returns the MCCMNC, or %NULL if not available.
             */
            get_physical_ci(): string;
            /**
             * Get the average reference signal received power in dBm.
             * @returns the RSRP, or -%G_MAXDOUBLE if not available.
             */
            get_rsrp(): number;
            /**
             * Get the average reference signal received quality in dB.
             * @returns the RSRQ, or -%G_MAXDOUBLE if not available.
             */
            get_rsrq(): number;
            /**
             * Get the serving cell type.
             * @returns the serving cell type, or %MM_SERVING_CELL_TYPE_INVALID if not available.
             */
            get_serving_cell_type(): ServingCellType;
            /**
             * Get the signal to interference and noise ratio.
             * @returns the SINR, or -%G_MAXDOUBLE if not available.
             */
            get_sinr(): number;
            /**
             * Get the two- or three- byte Tracking Area Code of the base station.
             *
             * Encoded in upper-case hexadecimal format without leading zeros,
             * as specified in 3GPP TS 27.007.
             * @returns the MCCMNC, or %NULL if not available.
             */
            get_tac(): string;
            /**
             * Get the timing advance.
             * @returns the timing advance, or %G_MAXUINT if not available.
             */
            get_timing_advance(): number;
        }

        namespace CellInfoTdscdma {
            // Constructor properties interface

            interface ConstructorProps extends CellInfo.ConstructorProps {}
        }

        /**
         * The #MMCellInfoTdscdma structure contains private data and should only be
         * accessed using the provided API.
         */
        class CellInfoTdscdma extends CellInfo {
            static $gtype: GObject.GType<CellInfoTdscdma>;

            // Constructors

            constructor(properties?: Partial<CellInfoTdscdma.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Methods

            /**
             * Get the cell parameter id.
             * @returns the cell parameter id, or %G_MAXUINT if not available.
             */
            get_cell_parameter_id(): number;
            /**
             * Get the two- or four-byte Cell Identifier.
             *
             * Encoded in upper-case hexadecimal format without leading zeros,
             * as specified in 3GPP TS 27.007.
             * @returns the MCCMNC, or %NULL if not available.
             */
            get_ci(): string;
            /**
             * Get the two-byte Location Area Code of the base station.
             *
             * Encoded in upper-case hexadecimal format without leading zeros,
             * as specified in 3GPP TS 27.007.
             * @returns the MCCMNC, or %NULL if not available.
             */
            get_lac(): string;
            /**
             * Get the PLMN MCC/MNC.
             * @returns the MCCMNC, or %NULL if not available.
             */
            get_operator_id(): string;
            /**
             * Get the path loss of the cell.
             * @returns the path loss, or %G_MAXUINT if not available.
             */
            get_path_loss(): number;
            /**
             * Get the received signal code power.
             * @returns the RSCP, or -%G_MAXDOUBLE if not available.
             */
            get_rscp(): number;
            /**
             * Get the measured delay (in bit periods) of an access burst transmission
             * on the RACH or PRACH to the expected signal from a mobile station at zero
             * distance under static channel conditions.
             * @returns the timing advance, or %G_MAXUINT if not available.
             */
            get_timing_advance(): number;
            /**
             * Get the UTRA absolute RF channel number.
             * @returns the UARFCN, or %G_MAXUINT if not available.
             */
            get_uarfcn(): number;
        }

        namespace CellInfoUmts {
            // Constructor properties interface

            interface ConstructorProps extends CellInfo.ConstructorProps {}
        }

        /**
         * The #MMCellInfoUmts structure contains private data and should only be
         * accessed using the provided API.
         */
        class CellInfoUmts extends CellInfo {
            static $gtype: GObject.GType<CellInfoUmts>;

            // Constructors

            constructor(properties?: Partial<CellInfoUmts.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Methods

            /**
             * Get the two- or four-byte Cell Identifier.
             *
             * Encoded in upper-case hexadecimal format without leading zeros,
             * as specified in 3GPP TS 27.007.
             * @returns the MCCMNC, or %NULL if not available.
             */
            get_ci(): string;
            /**
             * Get the ECIO, the received energy per chip divided by the power density
             * in the band measured in dBm on the primary CPICH channel of the cell.
             * @returns the ECIO, or -%G_MAXDOUBLE if not available.
             */
            get_ecio(): number;
            /**
             * Get the frequency of the downlink in kHz while in FDD.
             * @returns the frequency, or %G_MAXUINT if not available.
             */
            get_frequency_fdd_dl(): number;
            /**
             * Get the frequency of the uplink in kHz while in FDD.
             * @returns the frequency, or %G_MAXUINT if not available.
             */
            get_frequency_fdd_ul(): number;
            /**
             * Get the frequency in kHz while in TDD.
             * @returns the frequency, or %G_MAXUINT if not available.
             */
            get_frequency_tdd(): number;
            /**
             * Get the two-byte Location Area Code of the base station.
             *
             * Encoded in upper-case hexadecimal format without leading zeros,
             * as specified in 3GPP TS 27.007.
             * @returns the MCCMNC, or %NULL if not available.
             */
            get_lac(): string;
            /**
             * Get the PLMN MCC/MNC.
             * @returns the MCCMNC, or %NULL if not available.
             */
            get_operator_id(): string;
            /**
             * Get the path loss of the cell.
             * @returns the path loss, or %G_MAXUINT if not available.
             */
            get_path_loss(): number;
            /**
             * Get the primary scrambling code.
             * @returns the PSC, or %G_MAXUINT if not available.
             */
            get_psc(): number;
            /**
             * Get the received signal code power.
             * @returns the RSCP, or -%G_MAXDOUBLE if not available.
             */
            get_rscp(): number;
            /**
             * Get the UTRA absolute RF channel number.
             * @returns the UARFCN, or %G_MAXUINT if not available.
             */
            get_uarfcn(): number;
        }

        namespace FirmwareProperties {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {}
        }

        /**
         * The #MMFirmwareProperties structure contains private data and should only be accessed
         * using the provided API.
         */
        class FirmwareProperties extends GObject.Object {
            static $gtype: GObject.GType<FirmwareProperties>;

            // Constructors

            constructor(properties?: Partial<FirmwareProperties.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static ['new'](image_type: FirmwareImageType, unique_id: string): FirmwareProperties;

            static new_from_dictionary(dictionary: GLib.Variant): FirmwareProperties;

            // Methods

            get_dictionary(): GLib.Variant;
            /**
             * Gets the boot version of a firmware image of type
             * %MM_FIRMWARE_IMAGE_TYPE_GOBI.
             * @returns The boot version, or %NULL if unknown. Do not free the returned value, it is owned by @self.
             */
            get_gobi_boot_version(): string;
            /**
             * Gets the MODEM unique ID of a firmware image of type
             * %MM_FIRMWARE_IMAGE_TYPE_GOBI.
             * @returns The PRI unique ID, or %NULL if unknown. Do not free the returned value, it is owned by @self.
             */
            get_gobi_modem_unique_id(): string;
            /**
             * Gets the PRI info of a firmware image of type %MM_FIRMWARE_IMAGE_TYPE_GOBI.
             * @returns The PRI info, or %NULL if unknown. Do not free the returned value, it is owned by @self.
             */
            get_gobi_pri_info(): string;
            /**
             * Gets the PRI unique ID of a firmware image of type
             * %MM_FIRMWARE_IMAGE_TYPE_GOBI.
             * @returns The PRI unique ID, or %NULL if unknown. Do not free the returned value, it is owned by @self.
             */
            get_gobi_pri_unique_id(): string;
            /**
             * Gets the PRI version of a firmware image of type %MM_FIRMWARE_IMAGE_TYPE_GOBI.
             * @returns The PRI version, or %NULL if unknown. Do not free the returned value, it is owned by @self.
             */
            get_gobi_pri_version(): string;
            /**
             * Gets the type of the firmare image.
             * @returns A #MMFirmwareImageType specifying The type of the image.
             */
            get_image_type(): FirmwareImageType;
            /**
             * Gets the unique ID of the firmare image.
             * @returns The ID of the image. Do not free the returned value, it is owned by @self.
             */
            get_unique_id(): string;
            set_gobi_boot_version(version: string): void;
            set_gobi_modem_unique_id(id: string): void;
            set_gobi_pri_info(info: string): void;
            set_gobi_pri_unique_id(id: string): void;
            set_gobi_pri_version(version: string): void;
        }

        namespace FirmwareUpdateSettings {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {}
        }

        /**
         * The #MMFirmwareUpdateSettings structure contains private data and should only be accessed
         * using the provided API.
         */
        class FirmwareUpdateSettings extends GObject.Object {
            static $gtype: GObject.GType<FirmwareUpdateSettings>;

            // Constructors

            constructor(properties?: Partial<FirmwareUpdateSettings.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Methods

            /**
             * Gets the list of device ids used to identify the device during a firmware
             * update operation.
             * @returns The list of device ids, or %NULL if unknown. Do not free the returned value, it is owned by @self.
             */
            get_device_ids(): string[];
            /**
             * Gets the AT command that should be sent to the module to trigger a reset
             * into fastboot mode.
             *
             * Only applicable if the update method includes
             * %MM_MODEM_FIRMWARE_UPDATE_METHOD_FASTBOOT.
             * @returns The AT command string, or %NULL if unknown. Do not free the returned value, it is owned by @self.
             */
            get_fastboot_at(): string;
            /**
             * Gets the methods to use during the firmware update operation.
             * @returns a bitmask of #MMModemFirmwareUpdateMethod values.
             */
            get_method(): ModemFirmwareUpdateMethod;
            /**
             * Gets firmware version string.
             * @returns The version string, or %NULL if unknown. Do not free the returned value, it is owned by @self.
             */
            get_version(): string;
        }

        namespace GdbusBearerProxy {
            // Constructor properties interface

            interface ConstructorProps
                extends Gio.DBusProxy.ConstructorProps,
                    Gio.AsyncInitable.ConstructorProps,
                    Gio.DBusInterface.ConstructorProps,
                    Gio.Initable.ConstructorProps,
                    GdbusBearer.ConstructorProps {}
        }

        /**
         * The #MmGdbusBearerProxy structure contains only private data and should only be accessed using the provided API.
         */
        class GdbusBearerProxy
            extends Gio.DBusProxy
            implements Gio.AsyncInitable<GdbusBearerProxy>, Gio.DBusInterface, Gio.Initable, GdbusBearer
        {
            static $gtype: GObject.GType<GdbusBearerProxy>;

            // Constructors

            constructor(properties?: Partial<GdbusBearerProxy.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static new_finish(res: Gio.AsyncResult): GdbusBearerProxy;
            // Conflicted with Gio.AsyncInitable.new_finish

            static new_finish(...args: never[]): any;

            static new_for_bus_finish(res: Gio.AsyncResult): GdbusBearerProxy;

            static new_for_bus_sync(
                bus_type: Gio.BusType,
                flags: Gio.DBusProxyFlags,
                name: string,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
            ): GdbusBearerProxy;
            // Conflicted with Gio.DBusProxy.new_for_bus_sync

            static new_for_bus_sync(...args: never[]): any;

            static new_sync(
                connection: Gio.DBusConnection,
                flags: Gio.DBusProxyFlags,
                name: string | null,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
            ): GdbusBearerProxy;
            // Conflicted with Gio.DBusProxy.new_sync

            static new_sync(...args: never[]): any;

            // Static methods

            /**
             * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Bearer.top_of_page">org.freedesktop.ModemManager1.Bearer</link>. See g_dbus_proxy_new() for more details.
             *
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_bearer_proxy_new_finish() to get the result of the operation.
             *
             * See mm_gdbus_bearer_proxy_new_sync() for the synchronous, blocking version of this constructor.
             * @param connection A #GDBusConnection.
             * @param flags Flags from the #GDBusProxyFlags enumeration.
             * @param name A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
             * @param object_path An object path.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied.
             */
            static ['new'](
                connection: Gio.DBusConnection,
                flags: Gio.DBusProxyFlags,
                name: string | null,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<GdbusBearerProxy> | null,
            ): void;
            // Conflicted with Gio.DBusProxy.new
            static ['new'](...args: never[]): any;
            /**
             * Like mm_gdbus_bearer_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
             *
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_bearer_proxy_new_for_bus_finish() to get the result of the operation.
             *
             * See mm_gdbus_bearer_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
             * @param bus_type A #GBusType.
             * @param flags Flags from the #GDBusProxyFlags enumeration.
             * @param name A bus name (well-known or unique).
             * @param object_path An object path.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied.
             */
            static new_for_bus(
                bus_type: Gio.BusType,
                flags: Gio.DBusProxyFlags,
                name: string,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<GdbusBearerProxy> | null,
            ): void;
            // Conflicted with Gio.DBusProxy.new_for_bus
            static new_for_bus(...args: never[]): any;

            // Inherited properties
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.BearerType">"BearerType"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get bearer_type(): number;
            set bearer_type(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.BearerType">"BearerType"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get bearerType(): number;
            set bearerType(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.Connected">"Connected"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get connected(): boolean;
            set connected(val: boolean);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.ConnectionError">"ConnectionError"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get connection_error(): GLib.Variant;
            set connection_error(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.ConnectionError">"ConnectionError"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get connectionError(): GLib.Variant;
            set connectionError(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.Interface">"Interface"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get interface(): string;
            set interface(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.IpTimeout">"IpTimeout"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get ip_timeout(): number;
            set ip_timeout(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.IpTimeout">"IpTimeout"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get ipTimeout(): number;
            set ipTimeout(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.Ip4Config">"Ip4Config"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get ip4_config(): GLib.Variant;
            set ip4_config(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.Ip4Config">"Ip4Config"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get ip4Config(): GLib.Variant;
            set ip4Config(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.Ip6Config">"Ip6Config"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get ip6_config(): GLib.Variant;
            set ip6_config(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.Ip6Config">"Ip6Config"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get ip6Config(): GLib.Variant;
            set ip6Config(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.Multiplexed">"Multiplexed"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get multiplexed(): boolean;
            set multiplexed(val: boolean);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.ProfileId">"ProfileId"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get profile_id(): number;
            set profile_id(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.ProfileId">"ProfileId"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get profileId(): number;
            set profileId(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.Properties">"Properties"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get properties(): GLib.Variant;
            set properties(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.ReloadStatsSupported">"ReloadStatsSupported"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get reload_stats_supported(): boolean;
            set reload_stats_supported(val: boolean);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.ReloadStatsSupported">"ReloadStatsSupported"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get reloadStatsSupported(): boolean;
            set reloadStatsSupported(val: boolean);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.Stats">"Stats"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get stats(): GLib.Variant;
            set stats(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.Suspended">"Suspended"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get suspended(): boolean;
            set suspended(val: boolean);

            // Inherited methods
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            init_async(io_priority: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             * @returns %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present.
             */
            init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Finishes the async construction for the various g_async_initable_new
             * calls, returning the created object or %NULL on error.
             * @param res the #GAsyncResult from the callback
             * @returns a newly created #GObject,      or %NULL on error. Free with g_object_unref().
             */
            new_finish(res: Gio.AsyncResult): GdbusBearerProxy;
            // Conflicted with Gio.DBusProxy.new_finish
            new_finish(...args: never[]): any;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            vfunc_init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             */
            vfunc_init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             * @returns A #GDBusObject or %NULL. The returned reference should be freed with g_object_unref().
             */
            get_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             * @returns A #GDBusInterfaceInfo. Do not free.
             */
            get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            set_object(object?: Gio.DBusObject | null): void;
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             */
            vfunc_dup_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             */
            vfunc_get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            vfunc_set_object(object?: Gio.DBusObject | null): void;
            /**
             * Initializes the object implementing the interface.
             *
             * This method is intended for language bindings. If writing in C,
             * g_initable_new() should typically be used instead.
             *
             * The object must be initialized before any real use after initial
             * construction, either with this function or g_async_initable_init_async().
             *
             * Implementations may also support cancellation. If `cancellable` is not %NULL,
             * then initialization can be cancelled by triggering the cancellable object
             * from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
             * the object doesn't support cancellable initialization the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * If the object is not initialized, or initialization returns with an
             * error, then all operations on the object except g_object_ref() and
             * g_object_unref() are considered to be invalid, and have undefined
             * behaviour. See the [description][iface`Gio`.Initable#description] for more details.
             *
             * Callers should not assume that a class which implements #GInitable can be
             * initialized multiple times, unless the class explicitly documents itself as
             * supporting this. Generally, a class’ implementation of init() can assume
             * (and assert) that it will only be called once. Previously, this documentation
             * recommended all #GInitable implementations should be idempotent; that
             * recommendation was relaxed in GLib 2.54.
             *
             * If a class explicitly supports being initialized multiple times, it is
             * recommended that the method is idempotent: multiple calls with the same
             * arguments should return the same results. Only the first call initializes
             * the object; further calls return the result of the first call.
             *
             * One reason why a class might need to support idempotent initialization is if
             * it is designed to be used via the singleton pattern, with a
             * #GObjectClass.constructor that sometimes returns an existing instance.
             * In this pattern, a caller would expect to be able to call g_initable_init()
             * on the result of g_object_new(), regardless of whether it is in fact a new
             * instance.
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @returns %TRUE if successful. If an error has occurred, this function will     return %FALSE and set @error appropriately if present.
             */
            init(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Initializes the object implementing the interface.
             *
             * This method is intended for language bindings. If writing in C,
             * g_initable_new() should typically be used instead.
             *
             * The object must be initialized before any real use after initial
             * construction, either with this function or g_async_initable_init_async().
             *
             * Implementations may also support cancellation. If `cancellable` is not %NULL,
             * then initialization can be cancelled by triggering the cancellable object
             * from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
             * the object doesn't support cancellable initialization the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * If the object is not initialized, or initialization returns with an
             * error, then all operations on the object except g_object_ref() and
             * g_object_unref() are considered to be invalid, and have undefined
             * behaviour. See the [description][iface`Gio`.Initable#description] for more details.
             *
             * Callers should not assume that a class which implements #GInitable can be
             * initialized multiple times, unless the class explicitly documents itself as
             * supporting this. Generally, a class’ implementation of init() can assume
             * (and assert) that it will only be called once. Previously, this documentation
             * recommended all #GInitable implementations should be idempotent; that
             * recommendation was relaxed in GLib 2.54.
             *
             * If a class explicitly supports being initialized multiple times, it is
             * recommended that the method is idempotent: multiple calls with the same
             * arguments should return the same results. Only the first call initializes
             * the object; further calls return the result of the first call.
             *
             * One reason why a class might need to support idempotent initialization is if
             * it is designed to be used via the singleton pattern, with a
             * #GObjectClass.constructor that sometimes returns an existing instance.
             * In this pattern, a caller would expect to be able to call g_initable_init()
             * on the result of g_object_new(), regardless of whether it is in fact a new
             * instance.
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            vfunc_init(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Bearer.Connect">Connect()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_bearer_call_connect_finish() to get the result of the operation.
             *
             * See mm_gdbus_bearer_call_connect_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_connect(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Bearer.Connect">Connect()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_bearer_call_connect_finish() to get the result of the operation.
             *
             * See mm_gdbus_bearer_call_connect_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_connect(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Bearer.Connect">Connect()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_bearer_call_connect_finish() to get the result of the operation.
             *
             * See mm_gdbus_bearer_call_connect_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_connect(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_bearer_call_connect().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_bearer_call_connect().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_connect_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Bearer.Connect">Connect()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_bearer_call_connect() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_connect_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Bearer.Disconnect">Disconnect()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_bearer_call_disconnect_finish() to get the result of the operation.
             *
             * See mm_gdbus_bearer_call_disconnect_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_disconnect(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Bearer.Disconnect">Disconnect()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_bearer_call_disconnect_finish() to get the result of the operation.
             *
             * See mm_gdbus_bearer_call_disconnect_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_disconnect(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Bearer.Disconnect">Disconnect()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_bearer_call_disconnect_finish() to get the result of the operation.
             *
             * See mm_gdbus_bearer_call_disconnect_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_disconnect(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_bearer_call_disconnect().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_bearer_call_disconnect().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_disconnect_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Bearer.Disconnect">Disconnect()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_bearer_call_disconnect() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_disconnect_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Bearer.Connect">Connect()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_connect(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Bearer.Disconnect">Disconnect()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_disconnect(invocation: Gio.DBusMethodInvocation): void;
            vfunc_handle_connect(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_disconnect(invocation: Gio.DBusMethodInvocation): boolean;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace GdbusBearerSkeleton {
            // Constructor properties interface

            interface ConstructorProps
                extends Gio.DBusInterfaceSkeleton.ConstructorProps,
                    Gio.DBusInterface.ConstructorProps,
                    GdbusBearer.ConstructorProps {}
        }

        /**
         * The #MmGdbusBearerSkeleton structure contains only private data and should only be accessed using the provided API.
         */
        class GdbusBearerSkeleton extends Gio.DBusInterfaceSkeleton implements Gio.DBusInterface, GdbusBearer {
            static $gtype: GObject.GType<GdbusBearerSkeleton>;

            // Constructors

            constructor(properties?: Partial<GdbusBearerSkeleton.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static ['new'](): GdbusBearerSkeleton;

            // Inherited properties
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.BearerType">"BearerType"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get bearer_type(): number;
            set bearer_type(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.BearerType">"BearerType"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get bearerType(): number;
            set bearerType(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.Connected">"Connected"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get connected(): boolean;
            set connected(val: boolean);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.ConnectionError">"ConnectionError"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get connection_error(): GLib.Variant;
            set connection_error(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.ConnectionError">"ConnectionError"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get connectionError(): GLib.Variant;
            set connectionError(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.Interface">"Interface"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get interface(): string;
            set interface(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.IpTimeout">"IpTimeout"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get ip_timeout(): number;
            set ip_timeout(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.IpTimeout">"IpTimeout"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get ipTimeout(): number;
            set ipTimeout(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.Ip4Config">"Ip4Config"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get ip4_config(): GLib.Variant;
            set ip4_config(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.Ip4Config">"Ip4Config"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get ip4Config(): GLib.Variant;
            set ip4Config(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.Ip6Config">"Ip6Config"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get ip6_config(): GLib.Variant;
            set ip6_config(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.Ip6Config">"Ip6Config"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get ip6Config(): GLib.Variant;
            set ip6Config(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.Multiplexed">"Multiplexed"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get multiplexed(): boolean;
            set multiplexed(val: boolean);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.ProfileId">"ProfileId"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get profile_id(): number;
            set profile_id(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.ProfileId">"ProfileId"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get profileId(): number;
            set profileId(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.Properties">"Properties"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get properties(): GLib.Variant;
            set properties(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.ReloadStatsSupported">"ReloadStatsSupported"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get reload_stats_supported(): boolean;
            set reload_stats_supported(val: boolean);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.ReloadStatsSupported">"ReloadStatsSupported"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get reloadStatsSupported(): boolean;
            set reloadStatsSupported(val: boolean);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.Stats">"Stats"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get stats(): GLib.Variant;
            set stats(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.Suspended">"Suspended"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get suspended(): boolean;
            set suspended(val: boolean);

            // Inherited methods
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             * @returns A #GDBusObject or %NULL. The returned reference should be freed with g_object_unref().
             */
            get_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             * @returns A #GDBusInterfaceInfo. Do not free.
             */
            get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            set_object(object?: Gio.DBusObject | null): void;
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             */
            vfunc_dup_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             */
            vfunc_get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            vfunc_set_object(object?: Gio.DBusObject | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Bearer.Connect">Connect()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_bearer_call_connect_finish() to get the result of the operation.
             *
             * See mm_gdbus_bearer_call_connect_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_connect(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Bearer.Connect">Connect()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_bearer_call_connect_finish() to get the result of the operation.
             *
             * See mm_gdbus_bearer_call_connect_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_connect(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Bearer.Connect">Connect()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_bearer_call_connect_finish() to get the result of the operation.
             *
             * See mm_gdbus_bearer_call_connect_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_connect(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_bearer_call_connect().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_bearer_call_connect().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_connect_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Bearer.Connect">Connect()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_bearer_call_connect() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_connect_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Bearer.Disconnect">Disconnect()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_bearer_call_disconnect_finish() to get the result of the operation.
             *
             * See mm_gdbus_bearer_call_disconnect_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_disconnect(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Bearer.Disconnect">Disconnect()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_bearer_call_disconnect_finish() to get the result of the operation.
             *
             * See mm_gdbus_bearer_call_disconnect_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_disconnect(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Bearer.Disconnect">Disconnect()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_bearer_call_disconnect_finish() to get the result of the operation.
             *
             * See mm_gdbus_bearer_call_disconnect_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_disconnect(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_bearer_call_disconnect().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_bearer_call_disconnect().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_disconnect_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Bearer.Disconnect">Disconnect()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_bearer_call_disconnect() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_disconnect_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Bearer.Connect">Connect()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_connect(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Bearer.Disconnect">Disconnect()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_disconnect(invocation: Gio.DBusMethodInvocation): void;
            vfunc_handle_connect(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_disconnect(invocation: Gio.DBusMethodInvocation): boolean;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace GdbusCallProxy {
            // Constructor properties interface

            interface ConstructorProps
                extends Gio.DBusProxy.ConstructorProps,
                    Gio.AsyncInitable.ConstructorProps,
                    Gio.DBusInterface.ConstructorProps,
                    Gio.Initable.ConstructorProps,
                    GdbusCall.ConstructorProps {}
        }

        /**
         * The #MmGdbusCallProxy structure contains only private data and should only be accessed using the provided API.
         */
        class GdbusCallProxy
            extends Gio.DBusProxy
            implements Gio.AsyncInitable<GdbusCallProxy>, Gio.DBusInterface, Gio.Initable, GdbusCall
        {
            static $gtype: GObject.GType<GdbusCallProxy>;

            // Constructors

            constructor(properties?: Partial<GdbusCallProxy.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static new_finish(res: Gio.AsyncResult): GdbusCallProxy;
            // Conflicted with Gio.AsyncInitable.new_finish

            static new_finish(...args: never[]): any;

            static new_for_bus_finish(res: Gio.AsyncResult): GdbusCallProxy;

            static new_for_bus_sync(
                bus_type: Gio.BusType,
                flags: Gio.DBusProxyFlags,
                name: string,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
            ): GdbusCallProxy;
            // Conflicted with Gio.DBusProxy.new_for_bus_sync

            static new_for_bus_sync(...args: never[]): any;

            static new_sync(
                connection: Gio.DBusConnection,
                flags: Gio.DBusProxyFlags,
                name: string | null,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
            ): GdbusCallProxy;
            // Conflicted with Gio.DBusProxy.new_sync

            static new_sync(...args: never[]): any;

            // Static methods

            /**
             * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Call.top_of_page">org.freedesktop.ModemManager1.Call</link>. See g_dbus_proxy_new() for more details.
             *
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_proxy_new_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_proxy_new_sync() for the synchronous, blocking version of this constructor.
             * @param connection A #GDBusConnection.
             * @param flags Flags from the #GDBusProxyFlags enumeration.
             * @param name A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
             * @param object_path An object path.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied.
             */
            static ['new'](
                connection: Gio.DBusConnection,
                flags: Gio.DBusProxyFlags,
                name: string | null,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<GdbusCallProxy> | null,
            ): void;
            // Conflicted with Gio.DBusProxy.new
            static ['new'](...args: never[]): any;
            /**
             * Like mm_gdbus_call_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
             *
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_proxy_new_for_bus_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
             * @param bus_type A #GBusType.
             * @param flags Flags from the #GDBusProxyFlags enumeration.
             * @param name A bus name (well-known or unique).
             * @param object_path An object path.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied.
             */
            static new_for_bus(
                bus_type: Gio.BusType,
                flags: Gio.DBusProxyFlags,
                name: string,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<GdbusCallProxy> | null,
            ): void;
            // Conflicted with Gio.DBusProxy.new_for_bus
            static new_for_bus(...args: never[]): any;

            // Inherited properties
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Call.AudioFormat">"AudioFormat"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get audio_format(): GLib.Variant;
            set audio_format(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Call.AudioFormat">"AudioFormat"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get audioFormat(): GLib.Variant;
            set audioFormat(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Call.AudioPort">"AudioPort"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get audio_port(): string;
            set audio_port(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Call.AudioPort">"AudioPort"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get audioPort(): string;
            set audioPort(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Call.Direction">"Direction"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get direction(): number;
            set direction(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Call.Multiparty">"Multiparty"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get multiparty(): boolean;
            set multiparty(val: boolean);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Call.Number">"Number"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get number(): string;
            set number(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Call.State">"State"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get state(): number;
            set state(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Call.StateReason">"StateReason"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get state_reason(): number;
            set state_reason(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Call.StateReason">"StateReason"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get stateReason(): number;
            set stateReason(val: number);

            // Inherited methods
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            init_async(io_priority: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             * @returns %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present.
             */
            init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Finishes the async construction for the various g_async_initable_new
             * calls, returning the created object or %NULL on error.
             * @param res the #GAsyncResult from the callback
             * @returns a newly created #GObject,      or %NULL on error. Free with g_object_unref().
             */
            new_finish(res: Gio.AsyncResult): GdbusCallProxy;
            // Conflicted with Gio.DBusProxy.new_finish
            new_finish(...args: never[]): any;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            vfunc_init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             */
            vfunc_init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             * @returns A #GDBusObject or %NULL. The returned reference should be freed with g_object_unref().
             */
            get_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             * @returns A #GDBusInterfaceInfo. Do not free.
             */
            get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            set_object(object?: Gio.DBusObject | null): void;
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             */
            vfunc_dup_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             */
            vfunc_get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            vfunc_set_object(object?: Gio.DBusObject | null): void;
            /**
             * Initializes the object implementing the interface.
             *
             * This method is intended for language bindings. If writing in C,
             * g_initable_new() should typically be used instead.
             *
             * The object must be initialized before any real use after initial
             * construction, either with this function or g_async_initable_init_async().
             *
             * Implementations may also support cancellation. If `cancellable` is not %NULL,
             * then initialization can be cancelled by triggering the cancellable object
             * from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
             * the object doesn't support cancellable initialization the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * If the object is not initialized, or initialization returns with an
             * error, then all operations on the object except g_object_ref() and
             * g_object_unref() are considered to be invalid, and have undefined
             * behaviour. See the [description][iface`Gio`.Initable#description] for more details.
             *
             * Callers should not assume that a class which implements #GInitable can be
             * initialized multiple times, unless the class explicitly documents itself as
             * supporting this. Generally, a class’ implementation of init() can assume
             * (and assert) that it will only be called once. Previously, this documentation
             * recommended all #GInitable implementations should be idempotent; that
             * recommendation was relaxed in GLib 2.54.
             *
             * If a class explicitly supports being initialized multiple times, it is
             * recommended that the method is idempotent: multiple calls with the same
             * arguments should return the same results. Only the first call initializes
             * the object; further calls return the result of the first call.
             *
             * One reason why a class might need to support idempotent initialization is if
             * it is designed to be used via the singleton pattern, with a
             * #GObjectClass.constructor that sometimes returns an existing instance.
             * In this pattern, a caller would expect to be able to call g_initable_init()
             * on the result of g_object_new(), regardless of whether it is in fact a new
             * instance.
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @returns %TRUE if successful. If an error has occurred, this function will     return %FALSE and set @error appropriately if present.
             */
            init(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Initializes the object implementing the interface.
             *
             * This method is intended for language bindings. If writing in C,
             * g_initable_new() should typically be used instead.
             *
             * The object must be initialized before any real use after initial
             * construction, either with this function or g_async_initable_init_async().
             *
             * Implementations may also support cancellation. If `cancellable` is not %NULL,
             * then initialization can be cancelled by triggering the cancellable object
             * from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
             * the object doesn't support cancellable initialization the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * If the object is not initialized, or initialization returns with an
             * error, then all operations on the object except g_object_ref() and
             * g_object_unref() are considered to be invalid, and have undefined
             * behaviour. See the [description][iface`Gio`.Initable#description] for more details.
             *
             * Callers should not assume that a class which implements #GInitable can be
             * initialized multiple times, unless the class explicitly documents itself as
             * supporting this. Generally, a class’ implementation of init() can assume
             * (and assert) that it will only be called once. Previously, this documentation
             * recommended all #GInitable implementations should be idempotent; that
             * recommendation was relaxed in GLib 2.54.
             *
             * If a class explicitly supports being initialized multiple times, it is
             * recommended that the method is idempotent: multiple calls with the same
             * arguments should return the same results. Only the first call initializes
             * the object; further calls return the result of the first call.
             *
             * One reason why a class might need to support idempotent initialization is if
             * it is designed to be used via the singleton pattern, with a
             * #GObjectClass.constructor that sometimes returns an existing instance.
             * In this pattern, a caller would expect to be able to call g_initable_init()
             * on the result of g_object_new(), regardless of whether it is in fact a new
             * instance.
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            vfunc_init(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Accept">Accept()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_accept_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_accept_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_accept(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Accept">Accept()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_accept_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_accept_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_accept(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Accept">Accept()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_accept_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_accept_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_accept(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_call_call_accept().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_call_call_accept().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_accept_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Accept">Accept()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_call_call_accept() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_accept_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Deflect">Deflect()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_deflect_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_deflect_sync() for the synchronous, blocking version of this method.
             * @param arg_number Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_deflect(arg_number: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Deflect">Deflect()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_deflect_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_deflect_sync() for the synchronous, blocking version of this method.
             * @param arg_number Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_deflect(
                arg_number: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Deflect">Deflect()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_deflect_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_deflect_sync() for the synchronous, blocking version of this method.
             * @param arg_number Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_deflect(
                arg_number: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_call_call_deflect().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_call_call_deflect().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_deflect_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Deflect">Deflect()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_call_call_deflect() for the asynchronous version of this method.
             * @param arg_number Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_deflect_sync(arg_number: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Hangup">Hangup()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_hangup_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_hangup_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_hangup(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Hangup">Hangup()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_hangup_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_hangup_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_hangup(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Hangup">Hangup()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_hangup_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_hangup_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_hangup(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_call_call_hangup().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_call_call_hangup().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_hangup_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Hangup">Hangup()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_call_call_hangup() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_hangup_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.JoinMultiparty">JoinMultiparty()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_join_multiparty_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_join_multiparty_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_join_multiparty(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.JoinMultiparty">JoinMultiparty()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_join_multiparty_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_join_multiparty_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_join_multiparty(
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.JoinMultiparty">JoinMultiparty()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_join_multiparty_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_join_multiparty_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_join_multiparty(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_call_call_join_multiparty().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_call_call_join_multiparty().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_join_multiparty_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.JoinMultiparty">JoinMultiparty()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_call_call_join_multiparty() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_join_multiparty_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.LeaveMultiparty">LeaveMultiparty()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_leave_multiparty_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_leave_multiparty_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_leave_multiparty(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.LeaveMultiparty">LeaveMultiparty()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_leave_multiparty_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_leave_multiparty_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_leave_multiparty(
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.LeaveMultiparty">LeaveMultiparty()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_leave_multiparty_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_leave_multiparty_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_leave_multiparty(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_call_call_leave_multiparty().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_call_call_leave_multiparty().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_leave_multiparty_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.LeaveMultiparty">LeaveMultiparty()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_call_call_leave_multiparty() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_leave_multiparty_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.SendDtmf">SendDtmf()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_send_dtmf_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_send_dtmf_sync() for the synchronous, blocking version of this method.
             * @param arg_dtmf Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_send_dtmf(arg_dtmf: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.SendDtmf">SendDtmf()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_send_dtmf_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_send_dtmf_sync() for the synchronous, blocking version of this method.
             * @param arg_dtmf Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_send_dtmf(
                arg_dtmf: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.SendDtmf">SendDtmf()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_send_dtmf_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_send_dtmf_sync() for the synchronous, blocking version of this method.
             * @param arg_dtmf Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_send_dtmf(
                arg_dtmf: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_call_call_send_dtmf().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_call_call_send_dtmf().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_send_dtmf_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.SendDtmf">SendDtmf()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_call_call_send_dtmf() for the asynchronous version of this method.
             * @param arg_dtmf Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_send_dtmf_sync(arg_dtmf: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Start">Start()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_start_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_start_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_start(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Start">Start()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_start_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_start_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_start(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Start">Start()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_start_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_start_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_start(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_call_call_start().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_call_call_start().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_start_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Start">Start()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_call_call_start() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_start_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Accept">Accept()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_accept(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Deflect">Deflect()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_deflect(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Hangup">Hangup()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_hangup(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.JoinMultiparty">JoinMultiparty()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_join_multiparty(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.LeaveMultiparty">LeaveMultiparty()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_leave_multiparty(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.SendDtmf">SendDtmf()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_send_dtmf(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Start">Start()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_start(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Emits the <link linkend="gdbus-signal-org-freedesktop-ModemManager1-Call.DtmfReceived">"DtmfReceived"</link> D-Bus signal.
             * @param arg_dtmf Argument to pass with the signal.
             */
            emit_dtmf_received(arg_dtmf: string): void;
            /**
             * Emits the <link linkend="gdbus-signal-org-freedesktop-ModemManager1-Call.StateChanged">"StateChanged"</link> D-Bus signal.
             * @param arg_old Argument to pass with the signal.
             * @param arg_new Argument to pass with the signal.
             * @param arg_reason Argument to pass with the signal.
             */
            emit_state_changed(arg_old: number, arg_new: number, arg_reason: number): void;
            vfunc_dtmf_received(arg_dtmf: string): void;
            vfunc_handle_accept(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_deflect(invocation: Gio.DBusMethodInvocation, arg_number: string): boolean;
            vfunc_handle_hangup(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_join_multiparty(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_leave_multiparty(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_send_dtmf(invocation: Gio.DBusMethodInvocation, arg_dtmf: string): boolean;
            vfunc_handle_start(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_state_changed(arg_old: number, arg_new: number, arg_reason: number): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace GdbusCallSkeleton {
            // Constructor properties interface

            interface ConstructorProps
                extends Gio.DBusInterfaceSkeleton.ConstructorProps,
                    Gio.DBusInterface.ConstructorProps,
                    GdbusCall.ConstructorProps {}
        }

        /**
         * The #MmGdbusCallSkeleton structure contains only private data and should only be accessed using the provided API.
         */
        class GdbusCallSkeleton extends Gio.DBusInterfaceSkeleton implements Gio.DBusInterface, GdbusCall {
            static $gtype: GObject.GType<GdbusCallSkeleton>;

            // Constructors

            constructor(properties?: Partial<GdbusCallSkeleton.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static ['new'](): GdbusCallSkeleton;

            // Inherited properties
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Call.AudioFormat">"AudioFormat"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get audio_format(): GLib.Variant;
            set audio_format(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Call.AudioFormat">"AudioFormat"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get audioFormat(): GLib.Variant;
            set audioFormat(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Call.AudioPort">"AudioPort"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get audio_port(): string;
            set audio_port(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Call.AudioPort">"AudioPort"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get audioPort(): string;
            set audioPort(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Call.Direction">"Direction"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get direction(): number;
            set direction(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Call.Multiparty">"Multiparty"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get multiparty(): boolean;
            set multiparty(val: boolean);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Call.Number">"Number"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get number(): string;
            set number(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Call.State">"State"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get state(): number;
            set state(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Call.StateReason">"StateReason"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get state_reason(): number;
            set state_reason(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Call.StateReason">"StateReason"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get stateReason(): number;
            set stateReason(val: number);

            // Inherited methods
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             * @returns A #GDBusObject or %NULL. The returned reference should be freed with g_object_unref().
             */
            get_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             * @returns A #GDBusInterfaceInfo. Do not free.
             */
            get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            set_object(object?: Gio.DBusObject | null): void;
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             */
            vfunc_dup_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             */
            vfunc_get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            vfunc_set_object(object?: Gio.DBusObject | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Accept">Accept()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_accept_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_accept_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_accept(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Accept">Accept()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_accept_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_accept_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_accept(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Accept">Accept()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_accept_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_accept_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_accept(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_call_call_accept().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_call_call_accept().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_accept_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Accept">Accept()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_call_call_accept() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_accept_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Deflect">Deflect()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_deflect_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_deflect_sync() for the synchronous, blocking version of this method.
             * @param arg_number Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_deflect(arg_number: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Deflect">Deflect()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_deflect_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_deflect_sync() for the synchronous, blocking version of this method.
             * @param arg_number Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_deflect(
                arg_number: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Deflect">Deflect()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_deflect_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_deflect_sync() for the synchronous, blocking version of this method.
             * @param arg_number Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_deflect(
                arg_number: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_call_call_deflect().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_call_call_deflect().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_deflect_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Deflect">Deflect()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_call_call_deflect() for the asynchronous version of this method.
             * @param arg_number Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_deflect_sync(arg_number: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Hangup">Hangup()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_hangup_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_hangup_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_hangup(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Hangup">Hangup()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_hangup_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_hangup_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_hangup(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Hangup">Hangup()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_hangup_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_hangup_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_hangup(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_call_call_hangup().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_call_call_hangup().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_hangup_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Hangup">Hangup()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_call_call_hangup() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_hangup_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.JoinMultiparty">JoinMultiparty()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_join_multiparty_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_join_multiparty_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_join_multiparty(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.JoinMultiparty">JoinMultiparty()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_join_multiparty_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_join_multiparty_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_join_multiparty(
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.JoinMultiparty">JoinMultiparty()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_join_multiparty_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_join_multiparty_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_join_multiparty(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_call_call_join_multiparty().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_call_call_join_multiparty().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_join_multiparty_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.JoinMultiparty">JoinMultiparty()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_call_call_join_multiparty() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_join_multiparty_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.LeaveMultiparty">LeaveMultiparty()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_leave_multiparty_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_leave_multiparty_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_leave_multiparty(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.LeaveMultiparty">LeaveMultiparty()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_leave_multiparty_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_leave_multiparty_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_leave_multiparty(
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.LeaveMultiparty">LeaveMultiparty()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_leave_multiparty_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_leave_multiparty_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_leave_multiparty(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_call_call_leave_multiparty().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_call_call_leave_multiparty().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_leave_multiparty_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.LeaveMultiparty">LeaveMultiparty()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_call_call_leave_multiparty() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_leave_multiparty_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.SendDtmf">SendDtmf()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_send_dtmf_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_send_dtmf_sync() for the synchronous, blocking version of this method.
             * @param arg_dtmf Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_send_dtmf(arg_dtmf: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.SendDtmf">SendDtmf()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_send_dtmf_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_send_dtmf_sync() for the synchronous, blocking version of this method.
             * @param arg_dtmf Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_send_dtmf(
                arg_dtmf: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.SendDtmf">SendDtmf()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_send_dtmf_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_send_dtmf_sync() for the synchronous, blocking version of this method.
             * @param arg_dtmf Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_send_dtmf(
                arg_dtmf: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_call_call_send_dtmf().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_call_call_send_dtmf().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_send_dtmf_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.SendDtmf">SendDtmf()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_call_call_send_dtmf() for the asynchronous version of this method.
             * @param arg_dtmf Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_send_dtmf_sync(arg_dtmf: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Start">Start()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_start_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_start_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_start(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Start">Start()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_start_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_start_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_start(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Start">Start()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_start_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_start_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_start(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_call_call_start().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_call_call_start().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_start_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Start">Start()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_call_call_start() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_start_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Accept">Accept()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_accept(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Deflect">Deflect()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_deflect(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Hangup">Hangup()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_hangup(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.JoinMultiparty">JoinMultiparty()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_join_multiparty(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.LeaveMultiparty">LeaveMultiparty()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_leave_multiparty(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.SendDtmf">SendDtmf()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_send_dtmf(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Start">Start()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_start(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Emits the <link linkend="gdbus-signal-org-freedesktop-ModemManager1-Call.DtmfReceived">"DtmfReceived"</link> D-Bus signal.
             * @param arg_dtmf Argument to pass with the signal.
             */
            emit_dtmf_received(arg_dtmf: string): void;
            /**
             * Emits the <link linkend="gdbus-signal-org-freedesktop-ModemManager1-Call.StateChanged">"StateChanged"</link> D-Bus signal.
             * @param arg_old Argument to pass with the signal.
             * @param arg_new Argument to pass with the signal.
             * @param arg_reason Argument to pass with the signal.
             */
            emit_state_changed(arg_old: number, arg_new: number, arg_reason: number): void;
            vfunc_dtmf_received(arg_dtmf: string): void;
            vfunc_handle_accept(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_deflect(invocation: Gio.DBusMethodInvocation, arg_number: string): boolean;
            vfunc_handle_hangup(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_join_multiparty(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_leave_multiparty(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_send_dtmf(invocation: Gio.DBusMethodInvocation, arg_dtmf: string): boolean;
            vfunc_handle_start(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_state_changed(arg_old: number, arg_new: number, arg_reason: number): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace GdbusModem3gppProfileManagerProxy {
            // Constructor properties interface

            interface ConstructorProps
                extends Gio.DBusProxy.ConstructorProps,
                    Gio.AsyncInitable.ConstructorProps,
                    Gio.DBusInterface.ConstructorProps,
                    Gio.Initable.ConstructorProps,
                    GdbusModem3gppProfileManager.ConstructorProps {}
        }

        /**
         * The #MmGdbusModem3gppProfileManagerProxy structure contains only private data and should only be accessed using the provided API.
         */
        class GdbusModem3gppProfileManagerProxy
            extends Gio.DBusProxy
            implements
                Gio.AsyncInitable<GdbusModem3gppProfileManagerProxy>,
                Gio.DBusInterface,
                Gio.Initable,
                GdbusModem3gppProfileManager
        {
            static $gtype: GObject.GType<GdbusModem3gppProfileManagerProxy>;

            // Constructors

            constructor(properties?: Partial<GdbusModem3gppProfileManagerProxy.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static new_finish(res: Gio.AsyncResult): GdbusModem3gppProfileManagerProxy;
            // Conflicted with Gio.AsyncInitable.new_finish

            static new_finish(...args: never[]): any;

            static new_for_bus_finish(res: Gio.AsyncResult): GdbusModem3gppProfileManagerProxy;

            static new_for_bus_sync(
                bus_type: Gio.BusType,
                flags: Gio.DBusProxyFlags,
                name: string,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
            ): GdbusModem3gppProfileManagerProxy;
            // Conflicted with Gio.DBusProxy.new_for_bus_sync

            static new_for_bus_sync(...args: never[]): any;

            static new_sync(
                connection: Gio.DBusConnection,
                flags: Gio.DBusProxyFlags,
                name: string | null,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
            ): GdbusModem3gppProfileManagerProxy;
            // Conflicted with Gio.DBusProxy.new_sync

            static new_sync(...args: never[]): any;

            // Static methods

            /**
             * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.top_of_page">org.freedesktop.ModemManager1.Modem.Modem3gpp.ProfileManager</link>. See g_dbus_proxy_new() for more details.
             *
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_profile_manager_proxy_new_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_profile_manager_proxy_new_sync() for the synchronous, blocking version of this constructor.
             * @param connection A #GDBusConnection.
             * @param flags Flags from the #GDBusProxyFlags enumeration.
             * @param name A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
             * @param object_path An object path.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied.
             */
            static ['new'](
                connection: Gio.DBusConnection,
                flags: Gio.DBusProxyFlags,
                name: string | null,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<GdbusModem3gppProfileManagerProxy> | null,
            ): void;
            // Conflicted with Gio.DBusProxy.new
            static ['new'](...args: never[]): any;
            /**
             * Like mm_gdbus_modem3gpp_profile_manager_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
             *
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_profile_manager_proxy_new_for_bus_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_profile_manager_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
             * @param bus_type A #GBusType.
             * @param flags Flags from the #GDBusProxyFlags enumeration.
             * @param name A bus name (well-known or unique).
             * @param object_path An object path.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied.
             */
            static new_for_bus(
                bus_type: Gio.BusType,
                flags: Gio.DBusProxyFlags,
                name: string,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<GdbusModem3gppProfileManagerProxy> | null,
            ): void;
            // Conflicted with Gio.DBusProxy.new_for_bus
            static new_for_bus(...args: never[]): any;

            // Inherited properties
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.IndexField">"IndexField"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get index_field(): string;
            set index_field(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.IndexField">"IndexField"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get indexField(): string;
            set indexField(val: string);

            // Inherited methods
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            init_async(io_priority: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             * @returns %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present.
             */
            init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Finishes the async construction for the various g_async_initable_new
             * calls, returning the created object or %NULL on error.
             * @param res the #GAsyncResult from the callback
             * @returns a newly created #GObject,      or %NULL on error. Free with g_object_unref().
             */
            new_finish(res: Gio.AsyncResult): GdbusModem3gppProfileManagerProxy;
            // Conflicted with Gio.DBusProxy.new_finish
            new_finish(...args: never[]): any;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            vfunc_init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             */
            vfunc_init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             * @returns A #GDBusObject or %NULL. The returned reference should be freed with g_object_unref().
             */
            get_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             * @returns A #GDBusInterfaceInfo. Do not free.
             */
            get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            set_object(object?: Gio.DBusObject | null): void;
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             */
            vfunc_dup_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             */
            vfunc_get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            vfunc_set_object(object?: Gio.DBusObject | null): void;
            /**
             * Initializes the object implementing the interface.
             *
             * This method is intended for language bindings. If writing in C,
             * g_initable_new() should typically be used instead.
             *
             * The object must be initialized before any real use after initial
             * construction, either with this function or g_async_initable_init_async().
             *
             * Implementations may also support cancellation. If `cancellable` is not %NULL,
             * then initialization can be cancelled by triggering the cancellable object
             * from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
             * the object doesn't support cancellable initialization the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * If the object is not initialized, or initialization returns with an
             * error, then all operations on the object except g_object_ref() and
             * g_object_unref() are considered to be invalid, and have undefined
             * behaviour. See the [description][iface`Gio`.Initable#description] for more details.
             *
             * Callers should not assume that a class which implements #GInitable can be
             * initialized multiple times, unless the class explicitly documents itself as
             * supporting this. Generally, a class’ implementation of init() can assume
             * (and assert) that it will only be called once. Previously, this documentation
             * recommended all #GInitable implementations should be idempotent; that
             * recommendation was relaxed in GLib 2.54.
             *
             * If a class explicitly supports being initialized multiple times, it is
             * recommended that the method is idempotent: multiple calls with the same
             * arguments should return the same results. Only the first call initializes
             * the object; further calls return the result of the first call.
             *
             * One reason why a class might need to support idempotent initialization is if
             * it is designed to be used via the singleton pattern, with a
             * #GObjectClass.constructor that sometimes returns an existing instance.
             * In this pattern, a caller would expect to be able to call g_initable_init()
             * on the result of g_object_new(), regardless of whether it is in fact a new
             * instance.
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @returns %TRUE if successful. If an error has occurred, this function will     return %FALSE and set @error appropriately if present.
             */
            init(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Initializes the object implementing the interface.
             *
             * This method is intended for language bindings. If writing in C,
             * g_initable_new() should typically be used instead.
             *
             * The object must be initialized before any real use after initial
             * construction, either with this function or g_async_initable_init_async().
             *
             * Implementations may also support cancellation. If `cancellable` is not %NULL,
             * then initialization can be cancelled by triggering the cancellable object
             * from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
             * the object doesn't support cancellable initialization the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * If the object is not initialized, or initialization returns with an
             * error, then all operations on the object except g_object_ref() and
             * g_object_unref() are considered to be invalid, and have undefined
             * behaviour. See the [description][iface`Gio`.Initable#description] for more details.
             *
             * Callers should not assume that a class which implements #GInitable can be
             * initialized multiple times, unless the class explicitly documents itself as
             * supporting this. Generally, a class’ implementation of init() can assume
             * (and assert) that it will only be called once. Previously, this documentation
             * recommended all #GInitable implementations should be idempotent; that
             * recommendation was relaxed in GLib 2.54.
             *
             * If a class explicitly supports being initialized multiple times, it is
             * recommended that the method is idempotent: multiple calls with the same
             * arguments should return the same results. Only the first call initializes
             * the object; further calls return the result of the first call.
             *
             * One reason why a class might need to support idempotent initialization is if
             * it is designed to be used via the singleton pattern, with a
             * #GObjectClass.constructor that sometimes returns an existing instance.
             * In this pattern, a caller would expect to be able to call g_initable_init()
             * on the result of g_object_new(), regardless of whether it is in fact a new
             * instance.
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            vfunc_init(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.Delete">Delete()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_profile_manager_call_delete_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_profile_manager_call_delete_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_delete(arg_properties: GLib.Variant, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.Delete">Delete()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_profile_manager_call_delete_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_profile_manager_call_delete_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_delete(
                arg_properties: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.Delete">Delete()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_profile_manager_call_delete_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_profile_manager_call_delete_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_delete(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem3gpp_profile_manager_call_delete().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem3gpp_profile_manager_call_delete().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_delete_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.Delete">Delete()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem3gpp_profile_manager_call_delete() for the asynchronous version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_delete_sync(arg_properties: GLib.Variant, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.List">List()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_profile_manager_call_list_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_profile_manager_call_list_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_list(cancellable?: Gio.Cancellable | null): Promise<GLib.Variant | null>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.List">List()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_profile_manager_call_list_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_profile_manager_call_list_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_list(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.List">List()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_profile_manager_call_list_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_profile_manager_call_list_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_list(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<GLib.Variant | null> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem3gpp_profile_manager_call_list().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem3gpp_profile_manager_call_list().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_list_finish(res: Gio.AsyncResult): [boolean, GLib.Variant | null];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.List">List()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem3gpp_profile_manager_call_list() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_list_sync(cancellable?: Gio.Cancellable | null): [boolean, GLib.Variant | null];
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.Set">Set()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_profile_manager_call_set_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_profile_manager_call_set_sync() for the synchronous, blocking version of this method.
             * @param arg_requested_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set(
                arg_requested_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
            ): Promise<GLib.Variant | null>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.Set">Set()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_profile_manager_call_set_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_profile_manager_call_set_sync() for the synchronous, blocking version of this method.
             * @param arg_requested_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set(
                arg_requested_properties: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.Set">Set()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_profile_manager_call_set_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_profile_manager_call_set_sync() for the synchronous, blocking version of this method.
             * @param arg_requested_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set(
                arg_requested_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<GLib.Variant | null> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem3gpp_profile_manager_call_set().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem3gpp_profile_manager_call_set().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_finish(res: Gio.AsyncResult): [boolean, GLib.Variant | null];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.Set">Set()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem3gpp_profile_manager_call_set() for the asynchronous version of this method.
             * @param arg_requested_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_sync(
                arg_requested_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
            ): [boolean, GLib.Variant | null];
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.Delete">Delete()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_delete(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.List">List()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param profiles Parameter to return.
             */
            complete_list(invocation: Gio.DBusMethodInvocation, profiles: GLib.Variant): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.Set">Set()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param stored_properties Parameter to return.
             */
            complete_set(invocation: Gio.DBusMethodInvocation, stored_properties: GLib.Variant): void;
            /**
             * Emits the <link linkend="gdbus-signal-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.Updated">"Updated"</link> D-Bus signal.
             */
            emit_updated(): void;
            vfunc_handle_delete(invocation: Gio.DBusMethodInvocation, arg_properties: GLib.Variant): boolean;
            vfunc_handle_list(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_set(invocation: Gio.DBusMethodInvocation, arg_requested_properties: GLib.Variant): boolean;
            vfunc_updated(): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace GdbusModem3gppProfileManagerSkeleton {
            // Constructor properties interface

            interface ConstructorProps
                extends Gio.DBusInterfaceSkeleton.ConstructorProps,
                    Gio.DBusInterface.ConstructorProps,
                    GdbusModem3gppProfileManager.ConstructorProps {}
        }

        /**
         * The #MmGdbusModem3gppProfileManagerSkeleton structure contains only private data and should only be accessed using the provided API.
         */
        class GdbusModem3gppProfileManagerSkeleton
            extends Gio.DBusInterfaceSkeleton
            implements Gio.DBusInterface, GdbusModem3gppProfileManager
        {
            static $gtype: GObject.GType<GdbusModem3gppProfileManagerSkeleton>;

            // Constructors

            constructor(properties?: Partial<GdbusModem3gppProfileManagerSkeleton.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static ['new'](): GdbusModem3gppProfileManagerSkeleton;

            // Inherited properties
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.IndexField">"IndexField"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get index_field(): string;
            set index_field(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.IndexField">"IndexField"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get indexField(): string;
            set indexField(val: string);

            // Inherited methods
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             * @returns A #GDBusObject or %NULL. The returned reference should be freed with g_object_unref().
             */
            get_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             * @returns A #GDBusInterfaceInfo. Do not free.
             */
            get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            set_object(object?: Gio.DBusObject | null): void;
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             */
            vfunc_dup_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             */
            vfunc_get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            vfunc_set_object(object?: Gio.DBusObject | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.Delete">Delete()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_profile_manager_call_delete_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_profile_manager_call_delete_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_delete(arg_properties: GLib.Variant, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.Delete">Delete()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_profile_manager_call_delete_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_profile_manager_call_delete_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_delete(
                arg_properties: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.Delete">Delete()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_profile_manager_call_delete_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_profile_manager_call_delete_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_delete(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem3gpp_profile_manager_call_delete().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem3gpp_profile_manager_call_delete().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_delete_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.Delete">Delete()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem3gpp_profile_manager_call_delete() for the asynchronous version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_delete_sync(arg_properties: GLib.Variant, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.List">List()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_profile_manager_call_list_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_profile_manager_call_list_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_list(cancellable?: Gio.Cancellable | null): Promise<GLib.Variant | null>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.List">List()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_profile_manager_call_list_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_profile_manager_call_list_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_list(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.List">List()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_profile_manager_call_list_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_profile_manager_call_list_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_list(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<GLib.Variant | null> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem3gpp_profile_manager_call_list().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem3gpp_profile_manager_call_list().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_list_finish(res: Gio.AsyncResult): [boolean, GLib.Variant | null];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.List">List()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem3gpp_profile_manager_call_list() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_list_sync(cancellable?: Gio.Cancellable | null): [boolean, GLib.Variant | null];
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.Set">Set()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_profile_manager_call_set_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_profile_manager_call_set_sync() for the synchronous, blocking version of this method.
             * @param arg_requested_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set(
                arg_requested_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
            ): Promise<GLib.Variant | null>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.Set">Set()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_profile_manager_call_set_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_profile_manager_call_set_sync() for the synchronous, blocking version of this method.
             * @param arg_requested_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set(
                arg_requested_properties: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.Set">Set()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_profile_manager_call_set_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_profile_manager_call_set_sync() for the synchronous, blocking version of this method.
             * @param arg_requested_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set(
                arg_requested_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<GLib.Variant | null> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem3gpp_profile_manager_call_set().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem3gpp_profile_manager_call_set().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_finish(res: Gio.AsyncResult): [boolean, GLib.Variant | null];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.Set">Set()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem3gpp_profile_manager_call_set() for the asynchronous version of this method.
             * @param arg_requested_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_sync(
                arg_requested_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
            ): [boolean, GLib.Variant | null];
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.Delete">Delete()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_delete(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.List">List()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param profiles Parameter to return.
             */
            complete_list(invocation: Gio.DBusMethodInvocation, profiles: GLib.Variant): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.Set">Set()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param stored_properties Parameter to return.
             */
            complete_set(invocation: Gio.DBusMethodInvocation, stored_properties: GLib.Variant): void;
            /**
             * Emits the <link linkend="gdbus-signal-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.Updated">"Updated"</link> D-Bus signal.
             */
            emit_updated(): void;
            vfunc_handle_delete(invocation: Gio.DBusMethodInvocation, arg_properties: GLib.Variant): boolean;
            vfunc_handle_list(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_set(invocation: Gio.DBusMethodInvocation, arg_requested_properties: GLib.Variant): boolean;
            vfunc_updated(): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace GdbusModem3gppProxy {
            // Constructor properties interface

            interface ConstructorProps
                extends Gio.DBusProxy.ConstructorProps,
                    Gio.AsyncInitable.ConstructorProps,
                    Gio.DBusInterface.ConstructorProps,
                    Gio.Initable.ConstructorProps,
                    GdbusModem3gpp.ConstructorProps {}
        }

        /**
         * The #MmGdbusModem3gppProxy structure contains only private data and should only be accessed using the provided API.
         */
        class GdbusModem3gppProxy
            extends Gio.DBusProxy
            implements Gio.AsyncInitable<GdbusModem3gppProxy>, Gio.DBusInterface, Gio.Initable, GdbusModem3gpp
        {
            static $gtype: GObject.GType<GdbusModem3gppProxy>;

            // Constructors

            constructor(properties?: Partial<GdbusModem3gppProxy.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static new_finish(res: Gio.AsyncResult): GdbusModem3gppProxy;
            // Conflicted with Gio.AsyncInitable.new_finish

            static new_finish(...args: never[]): any;

            static new_for_bus_finish(res: Gio.AsyncResult): GdbusModem3gppProxy;

            static new_for_bus_sync(
                bus_type: Gio.BusType,
                flags: Gio.DBusProxyFlags,
                name: string,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
            ): GdbusModem3gppProxy;
            // Conflicted with Gio.DBusProxy.new_for_bus_sync

            static new_for_bus_sync(...args: never[]): any;

            static new_sync(
                connection: Gio.DBusConnection,
                flags: Gio.DBusProxyFlags,
                name: string | null,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
            ): GdbusModem3gppProxy;
            // Conflicted with Gio.DBusProxy.new_sync

            static new_sync(...args: never[]): any;

            // Static methods

            /**
             * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Modem3gpp.top_of_page">org.freedesktop.ModemManager1.Modem.Modem3gpp</link>. See g_dbus_proxy_new() for more details.
             *
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_proxy_new_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_proxy_new_sync() for the synchronous, blocking version of this constructor.
             * @param connection A #GDBusConnection.
             * @param flags Flags from the #GDBusProxyFlags enumeration.
             * @param name A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
             * @param object_path An object path.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied.
             */
            static ['new'](
                connection: Gio.DBusConnection,
                flags: Gio.DBusProxyFlags,
                name: string | null,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<GdbusModem3gppProxy> | null,
            ): void;
            // Conflicted with Gio.DBusProxy.new
            static ['new'](...args: never[]): any;
            /**
             * Like mm_gdbus_modem3gpp_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
             *
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_proxy_new_for_bus_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
             * @param bus_type A #GBusType.
             * @param flags Flags from the #GDBusProxyFlags enumeration.
             * @param name A bus name (well-known or unique).
             * @param object_path An object path.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied.
             */
            static new_for_bus(
                bus_type: Gio.BusType,
                flags: Gio.DBusProxyFlags,
                name: string,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<GdbusModem3gppProxy> | null,
            ): void;
            // Conflicted with Gio.DBusProxy.new_for_bus
            static new_for_bus(...args: never[]): any;

            // Inherited properties
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.EnabledFacilityLocks">"EnabledFacilityLocks"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get enabled_facility_locks(): number;
            set enabled_facility_locks(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.EnabledFacilityLocks">"EnabledFacilityLocks"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get enabledFacilityLocks(): number;
            set enabledFacilityLocks(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.EpsUeModeOperation">"EpsUeModeOperation"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get eps_ue_mode_operation(): number;
            set eps_ue_mode_operation(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.EpsUeModeOperation">"EpsUeModeOperation"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get epsUeModeOperation(): number;
            set epsUeModeOperation(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.Imei">"Imei"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get imei(): string;
            set imei(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.InitialEpsBearer">"InitialEpsBearer"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get initial_eps_bearer(): string;
            set initial_eps_bearer(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.InitialEpsBearer">"InitialEpsBearer"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get initialEpsBearer(): string;
            set initialEpsBearer(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.InitialEpsBearerSettings">"InitialEpsBearerSettings"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get initial_eps_bearer_settings(): GLib.Variant;
            set initial_eps_bearer_settings(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.InitialEpsBearerSettings">"InitialEpsBearerSettings"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get initialEpsBearerSettings(): GLib.Variant;
            set initialEpsBearerSettings(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.Nr5gRegistrationSettings">"Nr5gRegistrationSettings"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get nr5g_registration_settings(): GLib.Variant;
            set nr5g_registration_settings(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.Nr5gRegistrationSettings">"Nr5gRegistrationSettings"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get nr5gRegistrationSettings(): GLib.Variant;
            set nr5gRegistrationSettings(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.OperatorCode">"OperatorCode"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get operator_code(): string;
            set operator_code(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.OperatorCode">"OperatorCode"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get operatorCode(): string;
            set operatorCode(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.OperatorName">"OperatorName"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get operator_name(): string;
            set operator_name(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.OperatorName">"OperatorName"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get operatorName(): string;
            set operatorName(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.PacketServiceState">"PacketServiceState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get packet_service_state(): number;
            set packet_service_state(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.PacketServiceState">"PacketServiceState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get packetServiceState(): number;
            set packetServiceState(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.Pco">"Pco"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get pco(): GLib.Variant;
            set pco(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.RegistrationState">"RegistrationState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get registration_state(): number;
            set registration_state(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.RegistrationState">"RegistrationState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get registrationState(): number;
            set registrationState(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.SubscriptionState">"SubscriptionState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get subscription_state(): number;
            set subscription_state(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.SubscriptionState">"SubscriptionState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get subscriptionState(): number;
            set subscriptionState(val: number);

            // Inherited methods
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            init_async(io_priority: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             * @returns %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present.
             */
            init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Finishes the async construction for the various g_async_initable_new
             * calls, returning the created object or %NULL on error.
             * @param res the #GAsyncResult from the callback
             * @returns a newly created #GObject,      or %NULL on error. Free with g_object_unref().
             */
            new_finish(res: Gio.AsyncResult): GdbusModem3gppProxy;
            // Conflicted with Gio.DBusProxy.new_finish
            new_finish(...args: never[]): any;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            vfunc_init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             */
            vfunc_init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             * @returns A #GDBusObject or %NULL. The returned reference should be freed with g_object_unref().
             */
            get_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             * @returns A #GDBusInterfaceInfo. Do not free.
             */
            get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            set_object(object?: Gio.DBusObject | null): void;
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             */
            vfunc_dup_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             */
            vfunc_get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            vfunc_set_object(object?: Gio.DBusObject | null): void;
            /**
             * Initializes the object implementing the interface.
             *
             * This method is intended for language bindings. If writing in C,
             * g_initable_new() should typically be used instead.
             *
             * The object must be initialized before any real use after initial
             * construction, either with this function or g_async_initable_init_async().
             *
             * Implementations may also support cancellation. If `cancellable` is not %NULL,
             * then initialization can be cancelled by triggering the cancellable object
             * from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
             * the object doesn't support cancellable initialization the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * If the object is not initialized, or initialization returns with an
             * error, then all operations on the object except g_object_ref() and
             * g_object_unref() are considered to be invalid, and have undefined
             * behaviour. See the [description][iface`Gio`.Initable#description] for more details.
             *
             * Callers should not assume that a class which implements #GInitable can be
             * initialized multiple times, unless the class explicitly documents itself as
             * supporting this. Generally, a class’ implementation of init() can assume
             * (and assert) that it will only be called once. Previously, this documentation
             * recommended all #GInitable implementations should be idempotent; that
             * recommendation was relaxed in GLib 2.54.
             *
             * If a class explicitly supports being initialized multiple times, it is
             * recommended that the method is idempotent: multiple calls with the same
             * arguments should return the same results. Only the first call initializes
             * the object; further calls return the result of the first call.
             *
             * One reason why a class might need to support idempotent initialization is if
             * it is designed to be used via the singleton pattern, with a
             * #GObjectClass.constructor that sometimes returns an existing instance.
             * In this pattern, a caller would expect to be able to call g_initable_init()
             * on the result of g_object_new(), regardless of whether it is in fact a new
             * instance.
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @returns %TRUE if successful. If an error has occurred, this function will     return %FALSE and set @error appropriately if present.
             */
            init(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Initializes the object implementing the interface.
             *
             * This method is intended for language bindings. If writing in C,
             * g_initable_new() should typically be used instead.
             *
             * The object must be initialized before any real use after initial
             * construction, either with this function or g_async_initable_init_async().
             *
             * Implementations may also support cancellation. If `cancellable` is not %NULL,
             * then initialization can be cancelled by triggering the cancellable object
             * from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
             * the object doesn't support cancellable initialization the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * If the object is not initialized, or initialization returns with an
             * error, then all operations on the object except g_object_ref() and
             * g_object_unref() are considered to be invalid, and have undefined
             * behaviour. See the [description][iface`Gio`.Initable#description] for more details.
             *
             * Callers should not assume that a class which implements #GInitable can be
             * initialized multiple times, unless the class explicitly documents itself as
             * supporting this. Generally, a class’ implementation of init() can assume
             * (and assert) that it will only be called once. Previously, this documentation
             * recommended all #GInitable implementations should be idempotent; that
             * recommendation was relaxed in GLib 2.54.
             *
             * If a class explicitly supports being initialized multiple times, it is
             * recommended that the method is idempotent: multiple calls with the same
             * arguments should return the same results. Only the first call initializes
             * the object; further calls return the result of the first call.
             *
             * One reason why a class might need to support idempotent initialization is if
             * it is designed to be used via the singleton pattern, with a
             * #GObjectClass.constructor that sometimes returns an existing instance.
             * In this pattern, a caller would expect to be able to call g_initable_init()
             * on the result of g_object_new(), regardless of whether it is in fact a new
             * instance.
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            vfunc_init(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.DisableFacilityLock">DisableFacilityLock()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_disable_facility_lock_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_disable_facility_lock_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_disable_facility_lock(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.DisableFacilityLock">DisableFacilityLock()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_disable_facility_lock_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_disable_facility_lock_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_disable_facility_lock(
                arg_properties: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.DisableFacilityLock">DisableFacilityLock()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_disable_facility_lock_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_disable_facility_lock_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_disable_facility_lock(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem3gpp_call_disable_facility_lock().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem3gpp_call_disable_facility_lock().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_disable_facility_lock_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.DisableFacilityLock">DisableFacilityLock()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem3gpp_call_disable_facility_lock() for the asynchronous version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_disable_facility_lock_sync(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
            ): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.Register">Register()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_register_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_register_sync() for the synchronous, blocking version of this method.
             * @param arg_operator_id Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_register(arg_operator_id: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.Register">Register()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_register_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_register_sync() for the synchronous, blocking version of this method.
             * @param arg_operator_id Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_register(
                arg_operator_id: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.Register">Register()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_register_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_register_sync() for the synchronous, blocking version of this method.
             * @param arg_operator_id Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_register(
                arg_operator_id: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem3gpp_call_register().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem3gpp_call_register().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_register_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.Register">Register()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem3gpp_call_register() for the asynchronous version of this method.
             * @param arg_operator_id Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_register_sync(arg_operator_id: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.Scan">Scan()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_scan_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_scan_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_scan(cancellable?: Gio.Cancellable | null): Promise<GLib.Variant | null>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.Scan">Scan()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_scan_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_scan_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_scan(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.Scan">Scan()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_scan_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_scan_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_scan(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<GLib.Variant | null> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem3gpp_call_scan().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem3gpp_call_scan().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_scan_finish(res: Gio.AsyncResult): [boolean, GLib.Variant | null];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.Scan">Scan()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem3gpp_call_scan() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_scan_sync(cancellable?: Gio.Cancellable | null): [boolean, GLib.Variant | null];
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetCarrierLock">SetCarrierLock()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_set_carrier_lock_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_set_carrier_lock_sync() for the synchronous, blocking version of this method.
             * @param arg_data Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set_carrier_lock(arg_data: GLib.Variant, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetCarrierLock">SetCarrierLock()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_set_carrier_lock_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_set_carrier_lock_sync() for the synchronous, blocking version of this method.
             * @param arg_data Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_carrier_lock(
                arg_data: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetCarrierLock">SetCarrierLock()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_set_carrier_lock_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_set_carrier_lock_sync() for the synchronous, blocking version of this method.
             * @param arg_data Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_carrier_lock(
                arg_data: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem3gpp_call_set_carrier_lock().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem3gpp_call_set_carrier_lock().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_carrier_lock_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetCarrierLock">SetCarrierLock()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem3gpp_call_set_carrier_lock() for the asynchronous version of this method.
             * @param arg_data Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_carrier_lock_sync(arg_data: GLib.Variant, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetEpsUeModeOperation">SetEpsUeModeOperation()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_set_eps_ue_mode_operation_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_set_eps_ue_mode_operation_sync() for the synchronous, blocking version of this method.
             * @param arg_mode Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set_eps_ue_mode_operation(arg_mode: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetEpsUeModeOperation">SetEpsUeModeOperation()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_set_eps_ue_mode_operation_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_set_eps_ue_mode_operation_sync() for the synchronous, blocking version of this method.
             * @param arg_mode Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_eps_ue_mode_operation(
                arg_mode: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetEpsUeModeOperation">SetEpsUeModeOperation()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_set_eps_ue_mode_operation_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_set_eps_ue_mode_operation_sync() for the synchronous, blocking version of this method.
             * @param arg_mode Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_eps_ue_mode_operation(
                arg_mode: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem3gpp_call_set_eps_ue_mode_operation().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem3gpp_call_set_eps_ue_mode_operation().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_eps_ue_mode_operation_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetEpsUeModeOperation">SetEpsUeModeOperation()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem3gpp_call_set_eps_ue_mode_operation() for the asynchronous version of this method.
             * @param arg_mode Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_eps_ue_mode_operation_sync(arg_mode: number, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetInitialEpsBearerSettings">SetInitialEpsBearerSettings()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_set_initial_eps_bearer_settings_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_set_initial_eps_bearer_settings_sync() for the synchronous, blocking version of this method.
             * @param arg_settings Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set_initial_eps_bearer_settings(
                arg_settings: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetInitialEpsBearerSettings">SetInitialEpsBearerSettings()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_set_initial_eps_bearer_settings_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_set_initial_eps_bearer_settings_sync() for the synchronous, blocking version of this method.
             * @param arg_settings Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_initial_eps_bearer_settings(
                arg_settings: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetInitialEpsBearerSettings">SetInitialEpsBearerSettings()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_set_initial_eps_bearer_settings_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_set_initial_eps_bearer_settings_sync() for the synchronous, blocking version of this method.
             * @param arg_settings Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_initial_eps_bearer_settings(
                arg_settings: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem3gpp_call_set_initial_eps_bearer_settings().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem3gpp_call_set_initial_eps_bearer_settings().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_initial_eps_bearer_settings_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetInitialEpsBearerSettings">SetInitialEpsBearerSettings()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem3gpp_call_set_initial_eps_bearer_settings() for the asynchronous version of this method.
             * @param arg_settings Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_initial_eps_bearer_settings_sync(
                arg_settings: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
            ): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetNr5gRegistrationSettings">SetNr5gRegistrationSettings()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_set_nr5g_registration_settings_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_set_nr5g_registration_settings_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set_nr5g_registration_settings(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetNr5gRegistrationSettings">SetNr5gRegistrationSettings()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_set_nr5g_registration_settings_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_set_nr5g_registration_settings_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_nr5g_registration_settings(
                arg_properties: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetNr5gRegistrationSettings">SetNr5gRegistrationSettings()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_set_nr5g_registration_settings_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_set_nr5g_registration_settings_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_nr5g_registration_settings(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem3gpp_call_set_nr5g_registration_settings().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem3gpp_call_set_nr5g_registration_settings().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_nr5g_registration_settings_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetNr5gRegistrationSettings">SetNr5gRegistrationSettings()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem3gpp_call_set_nr5g_registration_settings() for the asynchronous version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_nr5g_registration_settings_sync(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
            ): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetPacketServiceState">SetPacketServiceState()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_set_packet_service_state_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_set_packet_service_state_sync() for the synchronous, blocking version of this method.
             * @param arg_state Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set_packet_service_state(arg_state: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetPacketServiceState">SetPacketServiceState()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_set_packet_service_state_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_set_packet_service_state_sync() for the synchronous, blocking version of this method.
             * @param arg_state Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_packet_service_state(
                arg_state: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetPacketServiceState">SetPacketServiceState()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_set_packet_service_state_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_set_packet_service_state_sync() for the synchronous, blocking version of this method.
             * @param arg_state Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_packet_service_state(
                arg_state: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem3gpp_call_set_packet_service_state().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem3gpp_call_set_packet_service_state().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_packet_service_state_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetPacketServiceState">SetPacketServiceState()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem3gpp_call_set_packet_service_state() for the asynchronous version of this method.
             * @param arg_state Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_packet_service_state_sync(arg_state: number, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.DisableFacilityLock">DisableFacilityLock()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_disable_facility_lock(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.Register">Register()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_register(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.Scan">Scan()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param results Parameter to return.
             */
            complete_scan(invocation: Gio.DBusMethodInvocation, results: GLib.Variant): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetCarrierLock">SetCarrierLock()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_set_carrier_lock(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetEpsUeModeOperation">SetEpsUeModeOperation()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_set_eps_ue_mode_operation(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetInitialEpsBearerSettings">SetInitialEpsBearerSettings()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_set_initial_eps_bearer_settings(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetNr5gRegistrationSettings">SetNr5gRegistrationSettings()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_set_nr5g_registration_settings(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetPacketServiceState">SetPacketServiceState()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_set_packet_service_state(invocation: Gio.DBusMethodInvocation): void;
            vfunc_handle_disable_facility_lock(
                invocation: Gio.DBusMethodInvocation,
                arg_properties: GLib.Variant,
            ): boolean;
            vfunc_handle_register(invocation: Gio.DBusMethodInvocation, arg_operator_id: string): boolean;
            vfunc_handle_scan(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_set_carrier_lock(invocation: Gio.DBusMethodInvocation, arg_data: GLib.Variant): boolean;
            vfunc_handle_set_eps_ue_mode_operation(invocation: Gio.DBusMethodInvocation, arg_mode: number): boolean;
            vfunc_handle_set_initial_eps_bearer_settings(
                invocation: Gio.DBusMethodInvocation,
                arg_settings: GLib.Variant,
            ): boolean;
            vfunc_handle_set_nr5g_registration_settings(
                invocation: Gio.DBusMethodInvocation,
                arg_properties: GLib.Variant,
            ): boolean;
            vfunc_handle_set_packet_service_state(invocation: Gio.DBusMethodInvocation, arg_state: number): boolean;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace GdbusModem3gppSkeleton {
            // Constructor properties interface

            interface ConstructorProps
                extends Gio.DBusInterfaceSkeleton.ConstructorProps,
                    Gio.DBusInterface.ConstructorProps,
                    GdbusModem3gpp.ConstructorProps {}
        }

        /**
         * The #MmGdbusModem3gppSkeleton structure contains only private data and should only be accessed using the provided API.
         */
        class GdbusModem3gppSkeleton extends Gio.DBusInterfaceSkeleton implements Gio.DBusInterface, GdbusModem3gpp {
            static $gtype: GObject.GType<GdbusModem3gppSkeleton>;

            // Constructors

            constructor(properties?: Partial<GdbusModem3gppSkeleton.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static ['new'](): GdbusModem3gppSkeleton;

            // Inherited properties
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.EnabledFacilityLocks">"EnabledFacilityLocks"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get enabled_facility_locks(): number;
            set enabled_facility_locks(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.EnabledFacilityLocks">"EnabledFacilityLocks"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get enabledFacilityLocks(): number;
            set enabledFacilityLocks(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.EpsUeModeOperation">"EpsUeModeOperation"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get eps_ue_mode_operation(): number;
            set eps_ue_mode_operation(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.EpsUeModeOperation">"EpsUeModeOperation"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get epsUeModeOperation(): number;
            set epsUeModeOperation(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.Imei">"Imei"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get imei(): string;
            set imei(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.InitialEpsBearer">"InitialEpsBearer"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get initial_eps_bearer(): string;
            set initial_eps_bearer(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.InitialEpsBearer">"InitialEpsBearer"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get initialEpsBearer(): string;
            set initialEpsBearer(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.InitialEpsBearerSettings">"InitialEpsBearerSettings"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get initial_eps_bearer_settings(): GLib.Variant;
            set initial_eps_bearer_settings(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.InitialEpsBearerSettings">"InitialEpsBearerSettings"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get initialEpsBearerSettings(): GLib.Variant;
            set initialEpsBearerSettings(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.Nr5gRegistrationSettings">"Nr5gRegistrationSettings"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get nr5g_registration_settings(): GLib.Variant;
            set nr5g_registration_settings(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.Nr5gRegistrationSettings">"Nr5gRegistrationSettings"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get nr5gRegistrationSettings(): GLib.Variant;
            set nr5gRegistrationSettings(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.OperatorCode">"OperatorCode"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get operator_code(): string;
            set operator_code(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.OperatorCode">"OperatorCode"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get operatorCode(): string;
            set operatorCode(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.OperatorName">"OperatorName"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get operator_name(): string;
            set operator_name(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.OperatorName">"OperatorName"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get operatorName(): string;
            set operatorName(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.PacketServiceState">"PacketServiceState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get packet_service_state(): number;
            set packet_service_state(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.PacketServiceState">"PacketServiceState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get packetServiceState(): number;
            set packetServiceState(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.Pco">"Pco"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get pco(): GLib.Variant;
            set pco(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.RegistrationState">"RegistrationState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get registration_state(): number;
            set registration_state(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.RegistrationState">"RegistrationState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get registrationState(): number;
            set registrationState(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.SubscriptionState">"SubscriptionState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get subscription_state(): number;
            set subscription_state(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.SubscriptionState">"SubscriptionState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get subscriptionState(): number;
            set subscriptionState(val: number);

            // Inherited methods
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             * @returns A #GDBusObject or %NULL. The returned reference should be freed with g_object_unref().
             */
            get_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             * @returns A #GDBusInterfaceInfo. Do not free.
             */
            get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            set_object(object?: Gio.DBusObject | null): void;
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             */
            vfunc_dup_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             */
            vfunc_get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            vfunc_set_object(object?: Gio.DBusObject | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.DisableFacilityLock">DisableFacilityLock()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_disable_facility_lock_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_disable_facility_lock_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_disable_facility_lock(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.DisableFacilityLock">DisableFacilityLock()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_disable_facility_lock_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_disable_facility_lock_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_disable_facility_lock(
                arg_properties: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.DisableFacilityLock">DisableFacilityLock()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_disable_facility_lock_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_disable_facility_lock_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_disable_facility_lock(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem3gpp_call_disable_facility_lock().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem3gpp_call_disable_facility_lock().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_disable_facility_lock_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.DisableFacilityLock">DisableFacilityLock()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem3gpp_call_disable_facility_lock() for the asynchronous version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_disable_facility_lock_sync(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
            ): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.Register">Register()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_register_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_register_sync() for the synchronous, blocking version of this method.
             * @param arg_operator_id Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_register(arg_operator_id: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.Register">Register()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_register_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_register_sync() for the synchronous, blocking version of this method.
             * @param arg_operator_id Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_register(
                arg_operator_id: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.Register">Register()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_register_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_register_sync() for the synchronous, blocking version of this method.
             * @param arg_operator_id Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_register(
                arg_operator_id: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem3gpp_call_register().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem3gpp_call_register().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_register_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.Register">Register()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem3gpp_call_register() for the asynchronous version of this method.
             * @param arg_operator_id Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_register_sync(arg_operator_id: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.Scan">Scan()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_scan_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_scan_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_scan(cancellable?: Gio.Cancellable | null): Promise<GLib.Variant | null>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.Scan">Scan()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_scan_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_scan_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_scan(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.Scan">Scan()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_scan_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_scan_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_scan(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<GLib.Variant | null> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem3gpp_call_scan().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem3gpp_call_scan().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_scan_finish(res: Gio.AsyncResult): [boolean, GLib.Variant | null];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.Scan">Scan()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem3gpp_call_scan() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_scan_sync(cancellable?: Gio.Cancellable | null): [boolean, GLib.Variant | null];
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetCarrierLock">SetCarrierLock()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_set_carrier_lock_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_set_carrier_lock_sync() for the synchronous, blocking version of this method.
             * @param arg_data Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set_carrier_lock(arg_data: GLib.Variant, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetCarrierLock">SetCarrierLock()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_set_carrier_lock_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_set_carrier_lock_sync() for the synchronous, blocking version of this method.
             * @param arg_data Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_carrier_lock(
                arg_data: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetCarrierLock">SetCarrierLock()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_set_carrier_lock_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_set_carrier_lock_sync() for the synchronous, blocking version of this method.
             * @param arg_data Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_carrier_lock(
                arg_data: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem3gpp_call_set_carrier_lock().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem3gpp_call_set_carrier_lock().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_carrier_lock_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetCarrierLock">SetCarrierLock()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem3gpp_call_set_carrier_lock() for the asynchronous version of this method.
             * @param arg_data Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_carrier_lock_sync(arg_data: GLib.Variant, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetEpsUeModeOperation">SetEpsUeModeOperation()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_set_eps_ue_mode_operation_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_set_eps_ue_mode_operation_sync() for the synchronous, blocking version of this method.
             * @param arg_mode Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set_eps_ue_mode_operation(arg_mode: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetEpsUeModeOperation">SetEpsUeModeOperation()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_set_eps_ue_mode_operation_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_set_eps_ue_mode_operation_sync() for the synchronous, blocking version of this method.
             * @param arg_mode Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_eps_ue_mode_operation(
                arg_mode: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetEpsUeModeOperation">SetEpsUeModeOperation()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_set_eps_ue_mode_operation_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_set_eps_ue_mode_operation_sync() for the synchronous, blocking version of this method.
             * @param arg_mode Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_eps_ue_mode_operation(
                arg_mode: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem3gpp_call_set_eps_ue_mode_operation().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem3gpp_call_set_eps_ue_mode_operation().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_eps_ue_mode_operation_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetEpsUeModeOperation">SetEpsUeModeOperation()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem3gpp_call_set_eps_ue_mode_operation() for the asynchronous version of this method.
             * @param arg_mode Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_eps_ue_mode_operation_sync(arg_mode: number, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetInitialEpsBearerSettings">SetInitialEpsBearerSettings()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_set_initial_eps_bearer_settings_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_set_initial_eps_bearer_settings_sync() for the synchronous, blocking version of this method.
             * @param arg_settings Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set_initial_eps_bearer_settings(
                arg_settings: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetInitialEpsBearerSettings">SetInitialEpsBearerSettings()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_set_initial_eps_bearer_settings_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_set_initial_eps_bearer_settings_sync() for the synchronous, blocking version of this method.
             * @param arg_settings Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_initial_eps_bearer_settings(
                arg_settings: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetInitialEpsBearerSettings">SetInitialEpsBearerSettings()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_set_initial_eps_bearer_settings_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_set_initial_eps_bearer_settings_sync() for the synchronous, blocking version of this method.
             * @param arg_settings Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_initial_eps_bearer_settings(
                arg_settings: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem3gpp_call_set_initial_eps_bearer_settings().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem3gpp_call_set_initial_eps_bearer_settings().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_initial_eps_bearer_settings_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetInitialEpsBearerSettings">SetInitialEpsBearerSettings()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem3gpp_call_set_initial_eps_bearer_settings() for the asynchronous version of this method.
             * @param arg_settings Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_initial_eps_bearer_settings_sync(
                arg_settings: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
            ): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetNr5gRegistrationSettings">SetNr5gRegistrationSettings()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_set_nr5g_registration_settings_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_set_nr5g_registration_settings_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set_nr5g_registration_settings(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetNr5gRegistrationSettings">SetNr5gRegistrationSettings()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_set_nr5g_registration_settings_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_set_nr5g_registration_settings_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_nr5g_registration_settings(
                arg_properties: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetNr5gRegistrationSettings">SetNr5gRegistrationSettings()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_set_nr5g_registration_settings_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_set_nr5g_registration_settings_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_nr5g_registration_settings(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem3gpp_call_set_nr5g_registration_settings().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem3gpp_call_set_nr5g_registration_settings().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_nr5g_registration_settings_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetNr5gRegistrationSettings">SetNr5gRegistrationSettings()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem3gpp_call_set_nr5g_registration_settings() for the asynchronous version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_nr5g_registration_settings_sync(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
            ): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetPacketServiceState">SetPacketServiceState()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_set_packet_service_state_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_set_packet_service_state_sync() for the synchronous, blocking version of this method.
             * @param arg_state Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set_packet_service_state(arg_state: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetPacketServiceState">SetPacketServiceState()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_set_packet_service_state_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_set_packet_service_state_sync() for the synchronous, blocking version of this method.
             * @param arg_state Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_packet_service_state(
                arg_state: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetPacketServiceState">SetPacketServiceState()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_set_packet_service_state_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_set_packet_service_state_sync() for the synchronous, blocking version of this method.
             * @param arg_state Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_packet_service_state(
                arg_state: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem3gpp_call_set_packet_service_state().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem3gpp_call_set_packet_service_state().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_packet_service_state_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetPacketServiceState">SetPacketServiceState()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem3gpp_call_set_packet_service_state() for the asynchronous version of this method.
             * @param arg_state Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_packet_service_state_sync(arg_state: number, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.DisableFacilityLock">DisableFacilityLock()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_disable_facility_lock(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.Register">Register()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_register(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.Scan">Scan()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param results Parameter to return.
             */
            complete_scan(invocation: Gio.DBusMethodInvocation, results: GLib.Variant): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetCarrierLock">SetCarrierLock()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_set_carrier_lock(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetEpsUeModeOperation">SetEpsUeModeOperation()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_set_eps_ue_mode_operation(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetInitialEpsBearerSettings">SetInitialEpsBearerSettings()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_set_initial_eps_bearer_settings(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetNr5gRegistrationSettings">SetNr5gRegistrationSettings()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_set_nr5g_registration_settings(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetPacketServiceState">SetPacketServiceState()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_set_packet_service_state(invocation: Gio.DBusMethodInvocation): void;
            vfunc_handle_disable_facility_lock(
                invocation: Gio.DBusMethodInvocation,
                arg_properties: GLib.Variant,
            ): boolean;
            vfunc_handle_register(invocation: Gio.DBusMethodInvocation, arg_operator_id: string): boolean;
            vfunc_handle_scan(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_set_carrier_lock(invocation: Gio.DBusMethodInvocation, arg_data: GLib.Variant): boolean;
            vfunc_handle_set_eps_ue_mode_operation(invocation: Gio.DBusMethodInvocation, arg_mode: number): boolean;
            vfunc_handle_set_initial_eps_bearer_settings(
                invocation: Gio.DBusMethodInvocation,
                arg_settings: GLib.Variant,
            ): boolean;
            vfunc_handle_set_nr5g_registration_settings(
                invocation: Gio.DBusMethodInvocation,
                arg_properties: GLib.Variant,
            ): boolean;
            vfunc_handle_set_packet_service_state(invocation: Gio.DBusMethodInvocation, arg_state: number): boolean;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace GdbusModem3gppUssdProxy {
            // Constructor properties interface

            interface ConstructorProps
                extends Gio.DBusProxy.ConstructorProps,
                    Gio.AsyncInitable.ConstructorProps,
                    Gio.DBusInterface.ConstructorProps,
                    Gio.Initable.ConstructorProps,
                    GdbusModem3gppUssd.ConstructorProps {}
        }

        /**
         * The #MmGdbusModem3gppUssdProxy structure contains only private data and should only be accessed using the provided API.
         */
        class GdbusModem3gppUssdProxy
            extends Gio.DBusProxy
            implements Gio.AsyncInitable<GdbusModem3gppUssdProxy>, Gio.DBusInterface, Gio.Initable, GdbusModem3gppUssd
        {
            static $gtype: GObject.GType<GdbusModem3gppUssdProxy>;

            // Constructors

            constructor(properties?: Partial<GdbusModem3gppUssdProxy.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static new_finish(res: Gio.AsyncResult): GdbusModem3gppUssdProxy;
            // Conflicted with Gio.AsyncInitable.new_finish

            static new_finish(...args: never[]): any;

            static new_for_bus_finish(res: Gio.AsyncResult): GdbusModem3gppUssdProxy;

            static new_for_bus_sync(
                bus_type: Gio.BusType,
                flags: Gio.DBusProxyFlags,
                name: string,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
            ): GdbusModem3gppUssdProxy;
            // Conflicted with Gio.DBusProxy.new_for_bus_sync

            static new_for_bus_sync(...args: never[]): any;

            static new_sync(
                connection: Gio.DBusConnection,
                flags: Gio.DBusProxyFlags,
                name: string | null,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
            ): GdbusModem3gppUssdProxy;
            // Conflicted with Gio.DBusProxy.new_sync

            static new_sync(...args: never[]): any;

            // Static methods

            /**
             * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.top_of_page">org.freedesktop.ModemManager1.Modem.Modem3gpp.Ussd</link>. See g_dbus_proxy_new() for more details.
             *
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_ussd_proxy_new_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_ussd_proxy_new_sync() for the synchronous, blocking version of this constructor.
             * @param connection A #GDBusConnection.
             * @param flags Flags from the #GDBusProxyFlags enumeration.
             * @param name A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
             * @param object_path An object path.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied.
             */
            static ['new'](
                connection: Gio.DBusConnection,
                flags: Gio.DBusProxyFlags,
                name: string | null,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<GdbusModem3gppUssdProxy> | null,
            ): void;
            // Conflicted with Gio.DBusProxy.new
            static ['new'](...args: never[]): any;
            /**
             * Like mm_gdbus_modem3gpp_ussd_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
             *
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_ussd_proxy_new_for_bus_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_ussd_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
             * @param bus_type A #GBusType.
             * @param flags Flags from the #GDBusProxyFlags enumeration.
             * @param name A bus name (well-known or unique).
             * @param object_path An object path.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied.
             */
            static new_for_bus(
                bus_type: Gio.BusType,
                flags: Gio.DBusProxyFlags,
                name: string,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<GdbusModem3gppUssdProxy> | null,
            ): void;
            // Conflicted with Gio.DBusProxy.new_for_bus
            static new_for_bus(...args: never[]): any;

            // Inherited properties
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.NetworkNotification">"NetworkNotification"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get network_notification(): string;
            set network_notification(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.NetworkNotification">"NetworkNotification"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get networkNotification(): string;
            set networkNotification(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.NetworkRequest">"NetworkRequest"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get network_request(): string;
            set network_request(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.NetworkRequest">"NetworkRequest"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get networkRequest(): string;
            set networkRequest(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.State">"State"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get state(): number;
            set state(val: number);

            // Inherited methods
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            init_async(io_priority: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             * @returns %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present.
             */
            init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Finishes the async construction for the various g_async_initable_new
             * calls, returning the created object or %NULL on error.
             * @param res the #GAsyncResult from the callback
             * @returns a newly created #GObject,      or %NULL on error. Free with g_object_unref().
             */
            new_finish(res: Gio.AsyncResult): GdbusModem3gppUssdProxy;
            // Conflicted with Gio.DBusProxy.new_finish
            new_finish(...args: never[]): any;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            vfunc_init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             */
            vfunc_init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             * @returns A #GDBusObject or %NULL. The returned reference should be freed with g_object_unref().
             */
            get_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             * @returns A #GDBusInterfaceInfo. Do not free.
             */
            get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            set_object(object?: Gio.DBusObject | null): void;
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             */
            vfunc_dup_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             */
            vfunc_get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            vfunc_set_object(object?: Gio.DBusObject | null): void;
            /**
             * Initializes the object implementing the interface.
             *
             * This method is intended for language bindings. If writing in C,
             * g_initable_new() should typically be used instead.
             *
             * The object must be initialized before any real use after initial
             * construction, either with this function or g_async_initable_init_async().
             *
             * Implementations may also support cancellation. If `cancellable` is not %NULL,
             * then initialization can be cancelled by triggering the cancellable object
             * from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
             * the object doesn't support cancellable initialization the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * If the object is not initialized, or initialization returns with an
             * error, then all operations on the object except g_object_ref() and
             * g_object_unref() are considered to be invalid, and have undefined
             * behaviour. See the [description][iface`Gio`.Initable#description] for more details.
             *
             * Callers should not assume that a class which implements #GInitable can be
             * initialized multiple times, unless the class explicitly documents itself as
             * supporting this. Generally, a class’ implementation of init() can assume
             * (and assert) that it will only be called once. Previously, this documentation
             * recommended all #GInitable implementations should be idempotent; that
             * recommendation was relaxed in GLib 2.54.
             *
             * If a class explicitly supports being initialized multiple times, it is
             * recommended that the method is idempotent: multiple calls with the same
             * arguments should return the same results. Only the first call initializes
             * the object; further calls return the result of the first call.
             *
             * One reason why a class might need to support idempotent initialization is if
             * it is designed to be used via the singleton pattern, with a
             * #GObjectClass.constructor that sometimes returns an existing instance.
             * In this pattern, a caller would expect to be able to call g_initable_init()
             * on the result of g_object_new(), regardless of whether it is in fact a new
             * instance.
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @returns %TRUE if successful. If an error has occurred, this function will     return %FALSE and set @error appropriately if present.
             */
            init(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Initializes the object implementing the interface.
             *
             * This method is intended for language bindings. If writing in C,
             * g_initable_new() should typically be used instead.
             *
             * The object must be initialized before any real use after initial
             * construction, either with this function or g_async_initable_init_async().
             *
             * Implementations may also support cancellation. If `cancellable` is not %NULL,
             * then initialization can be cancelled by triggering the cancellable object
             * from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
             * the object doesn't support cancellable initialization the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * If the object is not initialized, or initialization returns with an
             * error, then all operations on the object except g_object_ref() and
             * g_object_unref() are considered to be invalid, and have undefined
             * behaviour. See the [description][iface`Gio`.Initable#description] for more details.
             *
             * Callers should not assume that a class which implements #GInitable can be
             * initialized multiple times, unless the class explicitly documents itself as
             * supporting this. Generally, a class’ implementation of init() can assume
             * (and assert) that it will only be called once. Previously, this documentation
             * recommended all #GInitable implementations should be idempotent; that
             * recommendation was relaxed in GLib 2.54.
             *
             * If a class explicitly supports being initialized multiple times, it is
             * recommended that the method is idempotent: multiple calls with the same
             * arguments should return the same results. Only the first call initializes
             * the object; further calls return the result of the first call.
             *
             * One reason why a class might need to support idempotent initialization is if
             * it is designed to be used via the singleton pattern, with a
             * #GObjectClass.constructor that sometimes returns an existing instance.
             * In this pattern, a caller would expect to be able to call g_initable_init()
             * on the result of g_object_new(), regardless of whether it is in fact a new
             * instance.
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            vfunc_init(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.Cancel">Cancel()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_ussd_call_cancel_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_ussd_call_cancel_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_cancel(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.Cancel">Cancel()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_ussd_call_cancel_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_ussd_call_cancel_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_cancel(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.Cancel">Cancel()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_ussd_call_cancel_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_ussd_call_cancel_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_cancel(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem3gpp_ussd_call_cancel().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem3gpp_ussd_call_cancel().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_cancel_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.Cancel">Cancel()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem3gpp_ussd_call_cancel() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_cancel_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.Initiate">Initiate()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_ussd_call_initiate_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_ussd_call_initiate_sync() for the synchronous, blocking version of this method.
             * @param arg_command Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_initiate(arg_command: string, cancellable?: Gio.Cancellable | null): Promise<string>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.Initiate">Initiate()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_ussd_call_initiate_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_ussd_call_initiate_sync() for the synchronous, blocking version of this method.
             * @param arg_command Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_initiate(
                arg_command: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.Initiate">Initiate()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_ussd_call_initiate_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_ussd_call_initiate_sync() for the synchronous, blocking version of this method.
             * @param arg_command Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_initiate(
                arg_command: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<string> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem3gpp_ussd_call_initiate().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem3gpp_ussd_call_initiate().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_initiate_finish(res: Gio.AsyncResult): [boolean, string];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.Initiate">Initiate()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem3gpp_ussd_call_initiate() for the asynchronous version of this method.
             * @param arg_command Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_initiate_sync(arg_command: string, cancellable?: Gio.Cancellable | null): [boolean, string];
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.Respond">Respond()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_ussd_call_respond_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_ussd_call_respond_sync() for the synchronous, blocking version of this method.
             * @param arg_response Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_respond(arg_response: string, cancellable?: Gio.Cancellable | null): Promise<string>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.Respond">Respond()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_ussd_call_respond_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_ussd_call_respond_sync() for the synchronous, blocking version of this method.
             * @param arg_response Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_respond(
                arg_response: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.Respond">Respond()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_ussd_call_respond_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_ussd_call_respond_sync() for the synchronous, blocking version of this method.
             * @param arg_response Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_respond(
                arg_response: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<string> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem3gpp_ussd_call_respond().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem3gpp_ussd_call_respond().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_respond_finish(res: Gio.AsyncResult): [boolean, string];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.Respond">Respond()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem3gpp_ussd_call_respond() for the asynchronous version of this method.
             * @param arg_response Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_respond_sync(arg_response: string, cancellable?: Gio.Cancellable | null): [boolean, string];
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.Cancel">Cancel()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_cancel(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.Initiate">Initiate()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param reply Parameter to return.
             */
            complete_initiate(invocation: Gio.DBusMethodInvocation, reply: string): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.Respond">Respond()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param reply Parameter to return.
             */
            complete_respond(invocation: Gio.DBusMethodInvocation, reply: string): void;
            vfunc_handle_cancel(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_initiate(invocation: Gio.DBusMethodInvocation, arg_command: string): boolean;
            vfunc_handle_respond(invocation: Gio.DBusMethodInvocation, arg_response: string): boolean;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace GdbusModem3gppUssdSkeleton {
            // Constructor properties interface

            interface ConstructorProps
                extends Gio.DBusInterfaceSkeleton.ConstructorProps,
                    Gio.DBusInterface.ConstructorProps,
                    GdbusModem3gppUssd.ConstructorProps {}
        }

        /**
         * The #MmGdbusModem3gppUssdSkeleton structure contains only private data and should only be accessed using the provided API.
         */
        class GdbusModem3gppUssdSkeleton
            extends Gio.DBusInterfaceSkeleton
            implements Gio.DBusInterface, GdbusModem3gppUssd
        {
            static $gtype: GObject.GType<GdbusModem3gppUssdSkeleton>;

            // Constructors

            constructor(properties?: Partial<GdbusModem3gppUssdSkeleton.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static ['new'](): GdbusModem3gppUssdSkeleton;

            // Inherited properties
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.NetworkNotification">"NetworkNotification"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get network_notification(): string;
            set network_notification(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.NetworkNotification">"NetworkNotification"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get networkNotification(): string;
            set networkNotification(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.NetworkRequest">"NetworkRequest"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get network_request(): string;
            set network_request(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.NetworkRequest">"NetworkRequest"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get networkRequest(): string;
            set networkRequest(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.State">"State"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get state(): number;
            set state(val: number);

            // Inherited methods
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             * @returns A #GDBusObject or %NULL. The returned reference should be freed with g_object_unref().
             */
            get_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             * @returns A #GDBusInterfaceInfo. Do not free.
             */
            get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            set_object(object?: Gio.DBusObject | null): void;
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             */
            vfunc_dup_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             */
            vfunc_get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            vfunc_set_object(object?: Gio.DBusObject | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.Cancel">Cancel()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_ussd_call_cancel_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_ussd_call_cancel_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_cancel(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.Cancel">Cancel()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_ussd_call_cancel_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_ussd_call_cancel_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_cancel(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.Cancel">Cancel()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_ussd_call_cancel_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_ussd_call_cancel_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_cancel(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem3gpp_ussd_call_cancel().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem3gpp_ussd_call_cancel().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_cancel_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.Cancel">Cancel()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem3gpp_ussd_call_cancel() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_cancel_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.Initiate">Initiate()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_ussd_call_initiate_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_ussd_call_initiate_sync() for the synchronous, blocking version of this method.
             * @param arg_command Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_initiate(arg_command: string, cancellable?: Gio.Cancellable | null): Promise<string>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.Initiate">Initiate()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_ussd_call_initiate_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_ussd_call_initiate_sync() for the synchronous, blocking version of this method.
             * @param arg_command Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_initiate(
                arg_command: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.Initiate">Initiate()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_ussd_call_initiate_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_ussd_call_initiate_sync() for the synchronous, blocking version of this method.
             * @param arg_command Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_initiate(
                arg_command: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<string> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem3gpp_ussd_call_initiate().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem3gpp_ussd_call_initiate().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_initiate_finish(res: Gio.AsyncResult): [boolean, string];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.Initiate">Initiate()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem3gpp_ussd_call_initiate() for the asynchronous version of this method.
             * @param arg_command Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_initiate_sync(arg_command: string, cancellable?: Gio.Cancellable | null): [boolean, string];
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.Respond">Respond()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_ussd_call_respond_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_ussd_call_respond_sync() for the synchronous, blocking version of this method.
             * @param arg_response Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_respond(arg_response: string, cancellable?: Gio.Cancellable | null): Promise<string>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.Respond">Respond()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_ussd_call_respond_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_ussd_call_respond_sync() for the synchronous, blocking version of this method.
             * @param arg_response Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_respond(
                arg_response: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.Respond">Respond()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_ussd_call_respond_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_ussd_call_respond_sync() for the synchronous, blocking version of this method.
             * @param arg_response Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_respond(
                arg_response: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<string> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem3gpp_ussd_call_respond().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem3gpp_ussd_call_respond().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_respond_finish(res: Gio.AsyncResult): [boolean, string];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.Respond">Respond()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem3gpp_ussd_call_respond() for the asynchronous version of this method.
             * @param arg_response Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_respond_sync(arg_response: string, cancellable?: Gio.Cancellable | null): [boolean, string];
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.Cancel">Cancel()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_cancel(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.Initiate">Initiate()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param reply Parameter to return.
             */
            complete_initiate(invocation: Gio.DBusMethodInvocation, reply: string): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.Respond">Respond()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param reply Parameter to return.
             */
            complete_respond(invocation: Gio.DBusMethodInvocation, reply: string): void;
            vfunc_handle_cancel(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_initiate(invocation: Gio.DBusMethodInvocation, arg_command: string): boolean;
            vfunc_handle_respond(invocation: Gio.DBusMethodInvocation, arg_response: string): boolean;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace GdbusModemCdmaProxy {
            // Constructor properties interface

            interface ConstructorProps
                extends Gio.DBusProxy.ConstructorProps,
                    Gio.AsyncInitable.ConstructorProps,
                    Gio.DBusInterface.ConstructorProps,
                    Gio.Initable.ConstructorProps,
                    GdbusModemCdma.ConstructorProps {}
        }

        /**
         * The #MmGdbusModemCdmaProxy structure contains only private data and should only be accessed using the provided API.
         */
        class GdbusModemCdmaProxy
            extends Gio.DBusProxy
            implements Gio.AsyncInitable<GdbusModemCdmaProxy>, Gio.DBusInterface, Gio.Initable, GdbusModemCdma
        {
            static $gtype: GObject.GType<GdbusModemCdmaProxy>;

            // Constructors

            constructor(properties?: Partial<GdbusModemCdmaProxy.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static new_finish(res: Gio.AsyncResult): GdbusModemCdmaProxy;
            // Conflicted with Gio.AsyncInitable.new_finish

            static new_finish(...args: never[]): any;

            static new_for_bus_finish(res: Gio.AsyncResult): GdbusModemCdmaProxy;

            static new_for_bus_sync(
                bus_type: Gio.BusType,
                flags: Gio.DBusProxyFlags,
                name: string,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
            ): GdbusModemCdmaProxy;
            // Conflicted with Gio.DBusProxy.new_for_bus_sync

            static new_for_bus_sync(...args: never[]): any;

            static new_sync(
                connection: Gio.DBusConnection,
                flags: Gio.DBusProxyFlags,
                name: string | null,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
            ): GdbusModemCdmaProxy;
            // Conflicted with Gio.DBusProxy.new_sync

            static new_sync(...args: never[]): any;

            // Static methods

            /**
             * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-ModemCdma.top_of_page">org.freedesktop.ModemManager1.Modem.ModemCdma</link>. See g_dbus_proxy_new() for more details.
             *
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_cdma_proxy_new_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_cdma_proxy_new_sync() for the synchronous, blocking version of this constructor.
             * @param connection A #GDBusConnection.
             * @param flags Flags from the #GDBusProxyFlags enumeration.
             * @param name A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
             * @param object_path An object path.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied.
             */
            static ['new'](
                connection: Gio.DBusConnection,
                flags: Gio.DBusProxyFlags,
                name: string | null,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<GdbusModemCdmaProxy> | null,
            ): void;
            // Conflicted with Gio.DBusProxy.new
            static ['new'](...args: never[]): any;
            /**
             * Like mm_gdbus_modem_cdma_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
             *
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_cdma_proxy_new_for_bus_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_cdma_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
             * @param bus_type A #GBusType.
             * @param flags Flags from the #GDBusProxyFlags enumeration.
             * @param name A bus name (well-known or unique).
             * @param object_path An object path.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied.
             */
            static new_for_bus(
                bus_type: Gio.BusType,
                flags: Gio.DBusProxyFlags,
                name: string,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<GdbusModemCdmaProxy> | null,
            ): void;
            // Conflicted with Gio.DBusProxy.new_for_bus
            static new_for_bus(...args: never[]): any;

            // Inherited properties
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-ModemCdma.ActivationState">"ActivationState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get activation_state(): number;
            set activation_state(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-ModemCdma.ActivationState">"ActivationState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get activationState(): number;
            set activationState(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-ModemCdma.Cdma1xRegistrationState">"Cdma1xRegistrationState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get cdma1x_registration_state(): number;
            set cdma1x_registration_state(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-ModemCdma.Cdma1xRegistrationState">"Cdma1xRegistrationState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get cdma1xRegistrationState(): number;
            set cdma1xRegistrationState(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-ModemCdma.Esn">"Esn"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get esn(): string;
            set esn(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-ModemCdma.EvdoRegistrationState">"EvdoRegistrationState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get evdo_registration_state(): number;
            set evdo_registration_state(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-ModemCdma.EvdoRegistrationState">"EvdoRegistrationState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get evdoRegistrationState(): number;
            set evdoRegistrationState(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-ModemCdma.Meid">"Meid"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get meid(): string;
            set meid(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-ModemCdma.Nid">"Nid"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get nid(): number;
            set nid(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-ModemCdma.Sid">"Sid"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get sid(): number;
            set sid(val: number);

            // Inherited methods
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            init_async(io_priority: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             * @returns %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present.
             */
            init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Finishes the async construction for the various g_async_initable_new
             * calls, returning the created object or %NULL on error.
             * @param res the #GAsyncResult from the callback
             * @returns a newly created #GObject,      or %NULL on error. Free with g_object_unref().
             */
            new_finish(res: Gio.AsyncResult): GdbusModemCdmaProxy;
            // Conflicted with Gio.DBusProxy.new_finish
            new_finish(...args: never[]): any;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            vfunc_init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             */
            vfunc_init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             * @returns A #GDBusObject or %NULL. The returned reference should be freed with g_object_unref().
             */
            get_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             * @returns A #GDBusInterfaceInfo. Do not free.
             */
            get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            set_object(object?: Gio.DBusObject | null): void;
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             */
            vfunc_dup_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             */
            vfunc_get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            vfunc_set_object(object?: Gio.DBusObject | null): void;
            /**
             * Initializes the object implementing the interface.
             *
             * This method is intended for language bindings. If writing in C,
             * g_initable_new() should typically be used instead.
             *
             * The object must be initialized before any real use after initial
             * construction, either with this function or g_async_initable_init_async().
             *
             * Implementations may also support cancellation. If `cancellable` is not %NULL,
             * then initialization can be cancelled by triggering the cancellable object
             * from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
             * the object doesn't support cancellable initialization the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * If the object is not initialized, or initialization returns with an
             * error, then all operations on the object except g_object_ref() and
             * g_object_unref() are considered to be invalid, and have undefined
             * behaviour. See the [description][iface`Gio`.Initable#description] for more details.
             *
             * Callers should not assume that a class which implements #GInitable can be
             * initialized multiple times, unless the class explicitly documents itself as
             * supporting this. Generally, a class’ implementation of init() can assume
             * (and assert) that it will only be called once. Previously, this documentation
             * recommended all #GInitable implementations should be idempotent; that
             * recommendation was relaxed in GLib 2.54.
             *
             * If a class explicitly supports being initialized multiple times, it is
             * recommended that the method is idempotent: multiple calls with the same
             * arguments should return the same results. Only the first call initializes
             * the object; further calls return the result of the first call.
             *
             * One reason why a class might need to support idempotent initialization is if
             * it is designed to be used via the singleton pattern, with a
             * #GObjectClass.constructor that sometimes returns an existing instance.
             * In this pattern, a caller would expect to be able to call g_initable_init()
             * on the result of g_object_new(), regardless of whether it is in fact a new
             * instance.
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @returns %TRUE if successful. If an error has occurred, this function will     return %FALSE and set @error appropriately if present.
             */
            init(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Initializes the object implementing the interface.
             *
             * This method is intended for language bindings. If writing in C,
             * g_initable_new() should typically be used instead.
             *
             * The object must be initialized before any real use after initial
             * construction, either with this function or g_async_initable_init_async().
             *
             * Implementations may also support cancellation. If `cancellable` is not %NULL,
             * then initialization can be cancelled by triggering the cancellable object
             * from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
             * the object doesn't support cancellable initialization the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * If the object is not initialized, or initialization returns with an
             * error, then all operations on the object except g_object_ref() and
             * g_object_unref() are considered to be invalid, and have undefined
             * behaviour. See the [description][iface`Gio`.Initable#description] for more details.
             *
             * Callers should not assume that a class which implements #GInitable can be
             * initialized multiple times, unless the class explicitly documents itself as
             * supporting this. Generally, a class’ implementation of init() can assume
             * (and assert) that it will only be called once. Previously, this documentation
             * recommended all #GInitable implementations should be idempotent; that
             * recommendation was relaxed in GLib 2.54.
             *
             * If a class explicitly supports being initialized multiple times, it is
             * recommended that the method is idempotent: multiple calls with the same
             * arguments should return the same results. Only the first call initializes
             * the object; further calls return the result of the first call.
             *
             * One reason why a class might need to support idempotent initialization is if
             * it is designed to be used via the singleton pattern, with a
             * #GObjectClass.constructor that sometimes returns an existing instance.
             * In this pattern, a caller would expect to be able to call g_initable_init()
             * on the result of g_object_new(), regardless of whether it is in fact a new
             * instance.
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            vfunc_init(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-ModemCdma.Activate">Activate()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_cdma_call_activate_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_cdma_call_activate_sync() for the synchronous, blocking version of this method.
             * @param arg_carrier_code Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_activate(arg_carrier_code: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-ModemCdma.Activate">Activate()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_cdma_call_activate_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_cdma_call_activate_sync() for the synchronous, blocking version of this method.
             * @param arg_carrier_code Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_activate(
                arg_carrier_code: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-ModemCdma.Activate">Activate()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_cdma_call_activate_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_cdma_call_activate_sync() for the synchronous, blocking version of this method.
             * @param arg_carrier_code Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_activate(
                arg_carrier_code: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_cdma_call_activate().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_cdma_call_activate().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_activate_finish(res: Gio.AsyncResult): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-ModemCdma.ActivateManual">ActivateManual()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_cdma_call_activate_manual_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_cdma_call_activate_manual_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_activate_manual(arg_properties: GLib.Variant, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-ModemCdma.ActivateManual">ActivateManual()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_cdma_call_activate_manual_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_cdma_call_activate_manual_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_activate_manual(
                arg_properties: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-ModemCdma.ActivateManual">ActivateManual()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_cdma_call_activate_manual_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_cdma_call_activate_manual_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_activate_manual(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_cdma_call_activate_manual().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_cdma_call_activate_manual().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_activate_manual_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-ModemCdma.ActivateManual">ActivateManual()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_cdma_call_activate_manual() for the asynchronous version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_activate_manual_sync(arg_properties: GLib.Variant, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-ModemCdma.Activate">Activate()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_cdma_call_activate() for the asynchronous version of this method.
             * @param arg_carrier_code Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_activate_sync(arg_carrier_code: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-ModemCdma.Activate">Activate()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_activate(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-ModemCdma.ActivateManual">ActivateManual()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_activate_manual(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Emits the <link linkend="gdbus-signal-org-freedesktop-ModemManager1-Modem-ModemCdma.ActivationStateChanged">"ActivationStateChanged"</link> D-Bus signal.
             * @param arg_activation_state Argument to pass with the signal.
             * @param arg_activation_error Argument to pass with the signal.
             * @param arg_status_changes Argument to pass with the signal.
             */
            emit_activation_state_changed(
                arg_activation_state: number,
                arg_activation_error: number,
                arg_status_changes: GLib.Variant,
            ): void;
            vfunc_activation_state_changed(
                arg_activation_state: number,
                arg_activation_error: number,
                arg_status_changes: GLib.Variant,
            ): void;
            vfunc_handle_activate(invocation: Gio.DBusMethodInvocation, arg_carrier_code: string): boolean;
            vfunc_handle_activate_manual(invocation: Gio.DBusMethodInvocation, arg_properties: GLib.Variant): boolean;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace GdbusModemCdmaSkeleton {
            // Constructor properties interface

            interface ConstructorProps
                extends Gio.DBusInterfaceSkeleton.ConstructorProps,
                    Gio.DBusInterface.ConstructorProps,
                    GdbusModemCdma.ConstructorProps {}
        }

        /**
         * The #MmGdbusModemCdmaSkeleton structure contains only private data and should only be accessed using the provided API.
         */
        class GdbusModemCdmaSkeleton extends Gio.DBusInterfaceSkeleton implements Gio.DBusInterface, GdbusModemCdma {
            static $gtype: GObject.GType<GdbusModemCdmaSkeleton>;

            // Constructors

            constructor(properties?: Partial<GdbusModemCdmaSkeleton.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static ['new'](): GdbusModemCdmaSkeleton;

            // Inherited properties
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-ModemCdma.ActivationState">"ActivationState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get activation_state(): number;
            set activation_state(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-ModemCdma.ActivationState">"ActivationState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get activationState(): number;
            set activationState(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-ModemCdma.Cdma1xRegistrationState">"Cdma1xRegistrationState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get cdma1x_registration_state(): number;
            set cdma1x_registration_state(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-ModemCdma.Cdma1xRegistrationState">"Cdma1xRegistrationState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get cdma1xRegistrationState(): number;
            set cdma1xRegistrationState(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-ModemCdma.Esn">"Esn"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get esn(): string;
            set esn(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-ModemCdma.EvdoRegistrationState">"EvdoRegistrationState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get evdo_registration_state(): number;
            set evdo_registration_state(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-ModemCdma.EvdoRegistrationState">"EvdoRegistrationState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get evdoRegistrationState(): number;
            set evdoRegistrationState(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-ModemCdma.Meid">"Meid"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get meid(): string;
            set meid(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-ModemCdma.Nid">"Nid"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get nid(): number;
            set nid(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-ModemCdma.Sid">"Sid"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get sid(): number;
            set sid(val: number);

            // Inherited methods
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             * @returns A #GDBusObject or %NULL. The returned reference should be freed with g_object_unref().
             */
            get_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             * @returns A #GDBusInterfaceInfo. Do not free.
             */
            get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            set_object(object?: Gio.DBusObject | null): void;
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             */
            vfunc_dup_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             */
            vfunc_get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            vfunc_set_object(object?: Gio.DBusObject | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-ModemCdma.Activate">Activate()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_cdma_call_activate_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_cdma_call_activate_sync() for the synchronous, blocking version of this method.
             * @param arg_carrier_code Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_activate(arg_carrier_code: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-ModemCdma.Activate">Activate()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_cdma_call_activate_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_cdma_call_activate_sync() for the synchronous, blocking version of this method.
             * @param arg_carrier_code Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_activate(
                arg_carrier_code: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-ModemCdma.Activate">Activate()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_cdma_call_activate_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_cdma_call_activate_sync() for the synchronous, blocking version of this method.
             * @param arg_carrier_code Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_activate(
                arg_carrier_code: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_cdma_call_activate().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_cdma_call_activate().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_activate_finish(res: Gio.AsyncResult): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-ModemCdma.ActivateManual">ActivateManual()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_cdma_call_activate_manual_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_cdma_call_activate_manual_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_activate_manual(arg_properties: GLib.Variant, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-ModemCdma.ActivateManual">ActivateManual()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_cdma_call_activate_manual_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_cdma_call_activate_manual_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_activate_manual(
                arg_properties: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-ModemCdma.ActivateManual">ActivateManual()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_cdma_call_activate_manual_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_cdma_call_activate_manual_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_activate_manual(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_cdma_call_activate_manual().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_cdma_call_activate_manual().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_activate_manual_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-ModemCdma.ActivateManual">ActivateManual()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_cdma_call_activate_manual() for the asynchronous version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_activate_manual_sync(arg_properties: GLib.Variant, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-ModemCdma.Activate">Activate()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_cdma_call_activate() for the asynchronous version of this method.
             * @param arg_carrier_code Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_activate_sync(arg_carrier_code: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-ModemCdma.Activate">Activate()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_activate(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-ModemCdma.ActivateManual">ActivateManual()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_activate_manual(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Emits the <link linkend="gdbus-signal-org-freedesktop-ModemManager1-Modem-ModemCdma.ActivationStateChanged">"ActivationStateChanged"</link> D-Bus signal.
             * @param arg_activation_state Argument to pass with the signal.
             * @param arg_activation_error Argument to pass with the signal.
             * @param arg_status_changes Argument to pass with the signal.
             */
            emit_activation_state_changed(
                arg_activation_state: number,
                arg_activation_error: number,
                arg_status_changes: GLib.Variant,
            ): void;
            vfunc_activation_state_changed(
                arg_activation_state: number,
                arg_activation_error: number,
                arg_status_changes: GLib.Variant,
            ): void;
            vfunc_handle_activate(invocation: Gio.DBusMethodInvocation, arg_carrier_code: string): boolean;
            vfunc_handle_activate_manual(invocation: Gio.DBusMethodInvocation, arg_properties: GLib.Variant): boolean;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace GdbusModemFirmwareProxy {
            // Constructor properties interface

            interface ConstructorProps
                extends Gio.DBusProxy.ConstructorProps,
                    Gio.AsyncInitable.ConstructorProps,
                    Gio.DBusInterface.ConstructorProps,
                    Gio.Initable.ConstructorProps,
                    GdbusModemFirmware.ConstructorProps {}
        }

        /**
         * The #MmGdbusModemFirmwareProxy structure contains only private data and should only be accessed using the provided API.
         */
        class GdbusModemFirmwareProxy
            extends Gio.DBusProxy
            implements Gio.AsyncInitable<GdbusModemFirmwareProxy>, Gio.DBusInterface, Gio.Initable, GdbusModemFirmware
        {
            static $gtype: GObject.GType<GdbusModemFirmwareProxy>;

            // Constructors

            constructor(properties?: Partial<GdbusModemFirmwareProxy.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static new_finish(res: Gio.AsyncResult): GdbusModemFirmwareProxy;
            // Conflicted with Gio.AsyncInitable.new_finish

            static new_finish(...args: never[]): any;

            static new_for_bus_finish(res: Gio.AsyncResult): GdbusModemFirmwareProxy;

            static new_for_bus_sync(
                bus_type: Gio.BusType,
                flags: Gio.DBusProxyFlags,
                name: string,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
            ): GdbusModemFirmwareProxy;
            // Conflicted with Gio.DBusProxy.new_for_bus_sync

            static new_for_bus_sync(...args: never[]): any;

            static new_sync(
                connection: Gio.DBusConnection,
                flags: Gio.DBusProxyFlags,
                name: string | null,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
            ): GdbusModemFirmwareProxy;
            // Conflicted with Gio.DBusProxy.new_sync

            static new_sync(...args: never[]): any;

            // Static methods

            /**
             * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Firmware.top_of_page">org.freedesktop.ModemManager1.Modem.Firmware</link>. See g_dbus_proxy_new() for more details.
             *
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_firmware_proxy_new_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_firmware_proxy_new_sync() for the synchronous, blocking version of this constructor.
             * @param connection A #GDBusConnection.
             * @param flags Flags from the #GDBusProxyFlags enumeration.
             * @param name A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
             * @param object_path An object path.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied.
             */
            static ['new'](
                connection: Gio.DBusConnection,
                flags: Gio.DBusProxyFlags,
                name: string | null,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<GdbusModemFirmwareProxy> | null,
            ): void;
            // Conflicted with Gio.DBusProxy.new
            static ['new'](...args: never[]): any;
            /**
             * Like mm_gdbus_modem_firmware_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
             *
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_firmware_proxy_new_for_bus_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_firmware_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
             * @param bus_type A #GBusType.
             * @param flags Flags from the #GDBusProxyFlags enumeration.
             * @param name A bus name (well-known or unique).
             * @param object_path An object path.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied.
             */
            static new_for_bus(
                bus_type: Gio.BusType,
                flags: Gio.DBusProxyFlags,
                name: string,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<GdbusModemFirmwareProxy> | null,
            ): void;
            // Conflicted with Gio.DBusProxy.new_for_bus
            static new_for_bus(...args: never[]): any;

            // Inherited properties
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Firmware.UpdateSettings">"UpdateSettings"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get update_settings(): GLib.Variant;
            set update_settings(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Firmware.UpdateSettings">"UpdateSettings"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get updateSettings(): GLib.Variant;
            set updateSettings(val: GLib.Variant);

            // Inherited methods
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            init_async(io_priority: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             * @returns %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present.
             */
            init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Finishes the async construction for the various g_async_initable_new
             * calls, returning the created object or %NULL on error.
             * @param res the #GAsyncResult from the callback
             * @returns a newly created #GObject,      or %NULL on error. Free with g_object_unref().
             */
            new_finish(res: Gio.AsyncResult): GdbusModemFirmwareProxy;
            // Conflicted with Gio.DBusProxy.new_finish
            new_finish(...args: never[]): any;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            vfunc_init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             */
            vfunc_init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             * @returns A #GDBusObject or %NULL. The returned reference should be freed with g_object_unref().
             */
            get_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             * @returns A #GDBusInterfaceInfo. Do not free.
             */
            get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            set_object(object?: Gio.DBusObject | null): void;
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             */
            vfunc_dup_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             */
            vfunc_get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            vfunc_set_object(object?: Gio.DBusObject | null): void;
            /**
             * Initializes the object implementing the interface.
             *
             * This method is intended for language bindings. If writing in C,
             * g_initable_new() should typically be used instead.
             *
             * The object must be initialized before any real use after initial
             * construction, either with this function or g_async_initable_init_async().
             *
             * Implementations may also support cancellation. If `cancellable` is not %NULL,
             * then initialization can be cancelled by triggering the cancellable object
             * from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
             * the object doesn't support cancellable initialization the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * If the object is not initialized, or initialization returns with an
             * error, then all operations on the object except g_object_ref() and
             * g_object_unref() are considered to be invalid, and have undefined
             * behaviour. See the [description][iface`Gio`.Initable#description] for more details.
             *
             * Callers should not assume that a class which implements #GInitable can be
             * initialized multiple times, unless the class explicitly documents itself as
             * supporting this. Generally, a class’ implementation of init() can assume
             * (and assert) that it will only be called once. Previously, this documentation
             * recommended all #GInitable implementations should be idempotent; that
             * recommendation was relaxed in GLib 2.54.
             *
             * If a class explicitly supports being initialized multiple times, it is
             * recommended that the method is idempotent: multiple calls with the same
             * arguments should return the same results. Only the first call initializes
             * the object; further calls return the result of the first call.
             *
             * One reason why a class might need to support idempotent initialization is if
             * it is designed to be used via the singleton pattern, with a
             * #GObjectClass.constructor that sometimes returns an existing instance.
             * In this pattern, a caller would expect to be able to call g_initable_init()
             * on the result of g_object_new(), regardless of whether it is in fact a new
             * instance.
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @returns %TRUE if successful. If an error has occurred, this function will     return %FALSE and set @error appropriately if present.
             */
            init(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Initializes the object implementing the interface.
             *
             * This method is intended for language bindings. If writing in C,
             * g_initable_new() should typically be used instead.
             *
             * The object must be initialized before any real use after initial
             * construction, either with this function or g_async_initable_init_async().
             *
             * Implementations may also support cancellation. If `cancellable` is not %NULL,
             * then initialization can be cancelled by triggering the cancellable object
             * from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
             * the object doesn't support cancellable initialization the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * If the object is not initialized, or initialization returns with an
             * error, then all operations on the object except g_object_ref() and
             * g_object_unref() are considered to be invalid, and have undefined
             * behaviour. See the [description][iface`Gio`.Initable#description] for more details.
             *
             * Callers should not assume that a class which implements #GInitable can be
             * initialized multiple times, unless the class explicitly documents itself as
             * supporting this. Generally, a class’ implementation of init() can assume
             * (and assert) that it will only be called once. Previously, this documentation
             * recommended all #GInitable implementations should be idempotent; that
             * recommendation was relaxed in GLib 2.54.
             *
             * If a class explicitly supports being initialized multiple times, it is
             * recommended that the method is idempotent: multiple calls with the same
             * arguments should return the same results. Only the first call initializes
             * the object; further calls return the result of the first call.
             *
             * One reason why a class might need to support idempotent initialization is if
             * it is designed to be used via the singleton pattern, with a
             * #GObjectClass.constructor that sometimes returns an existing instance.
             * In this pattern, a caller would expect to be able to call g_initable_init()
             * on the result of g_object_new(), regardless of whether it is in fact a new
             * instance.
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            vfunc_init(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Firmware.List">List()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_firmware_call_list_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_firmware_call_list_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_list(cancellable?: Gio.Cancellable | null): Promise<[string, GLib.Variant | null]>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Firmware.List">List()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_firmware_call_list_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_firmware_call_list_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_list(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Firmware.List">List()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_firmware_call_list_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_firmware_call_list_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_list(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<[string, GLib.Variant | null]> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_firmware_call_list().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_firmware_call_list().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_list_finish(res: Gio.AsyncResult): [boolean, string, GLib.Variant | null];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Firmware.List">List()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_firmware_call_list() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_list_sync(cancellable?: Gio.Cancellable | null): [boolean, string, GLib.Variant | null];
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Firmware.Select">Select()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_firmware_call_select_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_firmware_call_select_sync() for the synchronous, blocking version of this method.
             * @param arg_uniqueid Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_select(arg_uniqueid: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Firmware.Select">Select()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_firmware_call_select_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_firmware_call_select_sync() for the synchronous, blocking version of this method.
             * @param arg_uniqueid Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_select(
                arg_uniqueid: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Firmware.Select">Select()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_firmware_call_select_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_firmware_call_select_sync() for the synchronous, blocking version of this method.
             * @param arg_uniqueid Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_select(
                arg_uniqueid: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_firmware_call_select().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_firmware_call_select().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_select_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Firmware.Select">Select()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_firmware_call_select() for the asynchronous version of this method.
             * @param arg_uniqueid Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_select_sync(arg_uniqueid: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Firmware.List">List()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param selected Parameter to return.
             * @param installed Parameter to return.
             */
            complete_list(invocation: Gio.DBusMethodInvocation, selected: string, installed: GLib.Variant): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Firmware.Select">Select()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_select(invocation: Gio.DBusMethodInvocation): void;
            vfunc_handle_list(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_select(invocation: Gio.DBusMethodInvocation, arg_uniqueid: string): boolean;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace GdbusModemFirmwareSkeleton {
            // Constructor properties interface

            interface ConstructorProps
                extends Gio.DBusInterfaceSkeleton.ConstructorProps,
                    Gio.DBusInterface.ConstructorProps,
                    GdbusModemFirmware.ConstructorProps {}
        }

        /**
         * The #MmGdbusModemFirmwareSkeleton structure contains only private data and should only be accessed using the provided API.
         */
        class GdbusModemFirmwareSkeleton
            extends Gio.DBusInterfaceSkeleton
            implements Gio.DBusInterface, GdbusModemFirmware
        {
            static $gtype: GObject.GType<GdbusModemFirmwareSkeleton>;

            // Constructors

            constructor(properties?: Partial<GdbusModemFirmwareSkeleton.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static ['new'](): GdbusModemFirmwareSkeleton;

            // Inherited properties
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Firmware.UpdateSettings">"UpdateSettings"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get update_settings(): GLib.Variant;
            set update_settings(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Firmware.UpdateSettings">"UpdateSettings"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get updateSettings(): GLib.Variant;
            set updateSettings(val: GLib.Variant);

            // Inherited methods
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             * @returns A #GDBusObject or %NULL. The returned reference should be freed with g_object_unref().
             */
            get_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             * @returns A #GDBusInterfaceInfo. Do not free.
             */
            get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            set_object(object?: Gio.DBusObject | null): void;
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             */
            vfunc_dup_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             */
            vfunc_get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            vfunc_set_object(object?: Gio.DBusObject | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Firmware.List">List()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_firmware_call_list_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_firmware_call_list_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_list(cancellable?: Gio.Cancellable | null): Promise<[string, GLib.Variant | null]>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Firmware.List">List()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_firmware_call_list_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_firmware_call_list_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_list(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Firmware.List">List()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_firmware_call_list_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_firmware_call_list_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_list(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<[string, GLib.Variant | null]> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_firmware_call_list().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_firmware_call_list().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_list_finish(res: Gio.AsyncResult): [boolean, string, GLib.Variant | null];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Firmware.List">List()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_firmware_call_list() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_list_sync(cancellable?: Gio.Cancellable | null): [boolean, string, GLib.Variant | null];
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Firmware.Select">Select()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_firmware_call_select_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_firmware_call_select_sync() for the synchronous, blocking version of this method.
             * @param arg_uniqueid Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_select(arg_uniqueid: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Firmware.Select">Select()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_firmware_call_select_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_firmware_call_select_sync() for the synchronous, blocking version of this method.
             * @param arg_uniqueid Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_select(
                arg_uniqueid: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Firmware.Select">Select()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_firmware_call_select_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_firmware_call_select_sync() for the synchronous, blocking version of this method.
             * @param arg_uniqueid Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_select(
                arg_uniqueid: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_firmware_call_select().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_firmware_call_select().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_select_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Firmware.Select">Select()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_firmware_call_select() for the asynchronous version of this method.
             * @param arg_uniqueid Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_select_sync(arg_uniqueid: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Firmware.List">List()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param selected Parameter to return.
             * @param installed Parameter to return.
             */
            complete_list(invocation: Gio.DBusMethodInvocation, selected: string, installed: GLib.Variant): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Firmware.Select">Select()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_select(invocation: Gio.DBusMethodInvocation): void;
            vfunc_handle_list(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_select(invocation: Gio.DBusMethodInvocation, arg_uniqueid: string): boolean;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace GdbusModemLocationProxy {
            // Constructor properties interface

            interface ConstructorProps
                extends Gio.DBusProxy.ConstructorProps,
                    Gio.AsyncInitable.ConstructorProps,
                    Gio.DBusInterface.ConstructorProps,
                    Gio.Initable.ConstructorProps,
                    GdbusModemLocation.ConstructorProps {}
        }

        /**
         * The #MmGdbusModemLocationProxy structure contains only private data and should only be accessed using the provided API.
         */
        class GdbusModemLocationProxy
            extends Gio.DBusProxy
            implements Gio.AsyncInitable<GdbusModemLocationProxy>, Gio.DBusInterface, Gio.Initable, GdbusModemLocation
        {
            static $gtype: GObject.GType<GdbusModemLocationProxy>;

            // Constructors

            constructor(properties?: Partial<GdbusModemLocationProxy.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static new_finish(res: Gio.AsyncResult): GdbusModemLocationProxy;
            // Conflicted with Gio.AsyncInitable.new_finish

            static new_finish(...args: never[]): any;

            static new_for_bus_finish(res: Gio.AsyncResult): GdbusModemLocationProxy;

            static new_for_bus_sync(
                bus_type: Gio.BusType,
                flags: Gio.DBusProxyFlags,
                name: string,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
            ): GdbusModemLocationProxy;
            // Conflicted with Gio.DBusProxy.new_for_bus_sync

            static new_for_bus_sync(...args: never[]): any;

            static new_sync(
                connection: Gio.DBusConnection,
                flags: Gio.DBusProxyFlags,
                name: string | null,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
            ): GdbusModemLocationProxy;
            // Conflicted with Gio.DBusProxy.new_sync

            static new_sync(...args: never[]): any;

            // Static methods

            /**
             * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Location.top_of_page">org.freedesktop.ModemManager1.Modem.Location</link>. See g_dbus_proxy_new() for more details.
             *
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_proxy_new_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_proxy_new_sync() for the synchronous, blocking version of this constructor.
             * @param connection A #GDBusConnection.
             * @param flags Flags from the #GDBusProxyFlags enumeration.
             * @param name A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
             * @param object_path An object path.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied.
             */
            static ['new'](
                connection: Gio.DBusConnection,
                flags: Gio.DBusProxyFlags,
                name: string | null,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<GdbusModemLocationProxy> | null,
            ): void;
            // Conflicted with Gio.DBusProxy.new
            static ['new'](...args: never[]): any;
            /**
             * Like mm_gdbus_modem_location_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
             *
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_proxy_new_for_bus_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
             * @param bus_type A #GBusType.
             * @param flags Flags from the #GDBusProxyFlags enumeration.
             * @param name A bus name (well-known or unique).
             * @param object_path An object path.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied.
             */
            static new_for_bus(
                bus_type: Gio.BusType,
                flags: Gio.DBusProxyFlags,
                name: string,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<GdbusModemLocationProxy> | null,
            ): void;
            // Conflicted with Gio.DBusProxy.new_for_bus
            static new_for_bus(...args: never[]): any;

            // Inherited properties
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Location.AssistanceDataServers">"AssistanceDataServers"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get assistance_data_servers(): string[];
            set assistance_data_servers(val: string[]);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Location.AssistanceDataServers">"AssistanceDataServers"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get assistanceDataServers(): string[];
            set assistanceDataServers(val: string[]);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Location.Capabilities">"Capabilities"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get capabilities(): number;
            set capabilities(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Location.Enabled">"Enabled"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get enabled(): number;
            set enabled(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Location.GpsRefreshRate">"GpsRefreshRate"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get gps_refresh_rate(): number;
            set gps_refresh_rate(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Location.GpsRefreshRate">"GpsRefreshRate"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get gpsRefreshRate(): number;
            set gpsRefreshRate(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Location.Location">"Location"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get location(): GLib.Variant;
            set location(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Location.SignalsLocation">"SignalsLocation"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get signals_location(): boolean;
            set signals_location(val: boolean);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Location.SignalsLocation">"SignalsLocation"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get signalsLocation(): boolean;
            set signalsLocation(val: boolean);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Location.SuplServer">"SuplServer"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get supl_server(): string;
            set supl_server(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Location.SuplServer">"SuplServer"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get suplServer(): string;
            set suplServer(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Location.SupportedAssistanceData">"SupportedAssistanceData"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get supported_assistance_data(): number;
            set supported_assistance_data(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Location.SupportedAssistanceData">"SupportedAssistanceData"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get supportedAssistanceData(): number;
            set supportedAssistanceData(val: number);

            // Inherited methods
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            init_async(io_priority: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             * @returns %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present.
             */
            init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Finishes the async construction for the various g_async_initable_new
             * calls, returning the created object or %NULL on error.
             * @param res the #GAsyncResult from the callback
             * @returns a newly created #GObject,      or %NULL on error. Free with g_object_unref().
             */
            new_finish(res: Gio.AsyncResult): GdbusModemLocationProxy;
            // Conflicted with Gio.DBusProxy.new_finish
            new_finish(...args: never[]): any;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            vfunc_init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             */
            vfunc_init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             * @returns A #GDBusObject or %NULL. The returned reference should be freed with g_object_unref().
             */
            get_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             * @returns A #GDBusInterfaceInfo. Do not free.
             */
            get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            set_object(object?: Gio.DBusObject | null): void;
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             */
            vfunc_dup_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             */
            vfunc_get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            vfunc_set_object(object?: Gio.DBusObject | null): void;
            /**
             * Initializes the object implementing the interface.
             *
             * This method is intended for language bindings. If writing in C,
             * g_initable_new() should typically be used instead.
             *
             * The object must be initialized before any real use after initial
             * construction, either with this function or g_async_initable_init_async().
             *
             * Implementations may also support cancellation. If `cancellable` is not %NULL,
             * then initialization can be cancelled by triggering the cancellable object
             * from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
             * the object doesn't support cancellable initialization the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * If the object is not initialized, or initialization returns with an
             * error, then all operations on the object except g_object_ref() and
             * g_object_unref() are considered to be invalid, and have undefined
             * behaviour. See the [description][iface`Gio`.Initable#description] for more details.
             *
             * Callers should not assume that a class which implements #GInitable can be
             * initialized multiple times, unless the class explicitly documents itself as
             * supporting this. Generally, a class’ implementation of init() can assume
             * (and assert) that it will only be called once. Previously, this documentation
             * recommended all #GInitable implementations should be idempotent; that
             * recommendation was relaxed in GLib 2.54.
             *
             * If a class explicitly supports being initialized multiple times, it is
             * recommended that the method is idempotent: multiple calls with the same
             * arguments should return the same results. Only the first call initializes
             * the object; further calls return the result of the first call.
             *
             * One reason why a class might need to support idempotent initialization is if
             * it is designed to be used via the singleton pattern, with a
             * #GObjectClass.constructor that sometimes returns an existing instance.
             * In this pattern, a caller would expect to be able to call g_initable_init()
             * on the result of g_object_new(), regardless of whether it is in fact a new
             * instance.
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @returns %TRUE if successful. If an error has occurred, this function will     return %FALSE and set @error appropriately if present.
             */
            init(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Initializes the object implementing the interface.
             *
             * This method is intended for language bindings. If writing in C,
             * g_initable_new() should typically be used instead.
             *
             * The object must be initialized before any real use after initial
             * construction, either with this function or g_async_initable_init_async().
             *
             * Implementations may also support cancellation. If `cancellable` is not %NULL,
             * then initialization can be cancelled by triggering the cancellable object
             * from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
             * the object doesn't support cancellable initialization the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * If the object is not initialized, or initialization returns with an
             * error, then all operations on the object except g_object_ref() and
             * g_object_unref() are considered to be invalid, and have undefined
             * behaviour. See the [description][iface`Gio`.Initable#description] for more details.
             *
             * Callers should not assume that a class which implements #GInitable can be
             * initialized multiple times, unless the class explicitly documents itself as
             * supporting this. Generally, a class’ implementation of init() can assume
             * (and assert) that it will only be called once. Previously, this documentation
             * recommended all #GInitable implementations should be idempotent; that
             * recommendation was relaxed in GLib 2.54.
             *
             * If a class explicitly supports being initialized multiple times, it is
             * recommended that the method is idempotent: multiple calls with the same
             * arguments should return the same results. Only the first call initializes
             * the object; further calls return the result of the first call.
             *
             * One reason why a class might need to support idempotent initialization is if
             * it is designed to be used via the singleton pattern, with a
             * #GObjectClass.constructor that sometimes returns an existing instance.
             * In this pattern, a caller would expect to be able to call g_initable_init()
             * on the result of g_object_new(), regardless of whether it is in fact a new
             * instance.
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            vfunc_init(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.GetLocation">GetLocation()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_call_get_location_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_call_get_location_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_get_location(cancellable?: Gio.Cancellable | null): Promise<GLib.Variant | null>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.GetLocation">GetLocation()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_call_get_location_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_call_get_location_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_get_location(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.GetLocation">GetLocation()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_call_get_location_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_call_get_location_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_get_location(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<GLib.Variant | null> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_location_call_get_location().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_location_call_get_location().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_get_location_finish(res: Gio.AsyncResult): [boolean, GLib.Variant | null];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.GetLocation">GetLocation()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_location_call_get_location() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_get_location_sync(cancellable?: Gio.Cancellable | null): [boolean, GLib.Variant | null];
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.InjectAssistanceData">InjectAssistanceData()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_call_inject_assistance_data_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_call_inject_assistance_data_sync() for the synchronous, blocking version of this method.
             * @param arg_data Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_inject_assistance_data(arg_data: GLib.Variant, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.InjectAssistanceData">InjectAssistanceData()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_call_inject_assistance_data_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_call_inject_assistance_data_sync() for the synchronous, blocking version of this method.
             * @param arg_data Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_inject_assistance_data(
                arg_data: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.InjectAssistanceData">InjectAssistanceData()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_call_inject_assistance_data_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_call_inject_assistance_data_sync() for the synchronous, blocking version of this method.
             * @param arg_data Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_inject_assistance_data(
                arg_data: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_location_call_inject_assistance_data().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_location_call_inject_assistance_data().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_inject_assistance_data_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.InjectAssistanceData">InjectAssistanceData()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_location_call_inject_assistance_data() for the asynchronous version of this method.
             * @param arg_data Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_inject_assistance_data_sync(arg_data: GLib.Variant, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.SetGpsRefreshRate">SetGpsRefreshRate()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_call_set_gps_refresh_rate_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_call_set_gps_refresh_rate_sync() for the synchronous, blocking version of this method.
             * @param arg_rate Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set_gps_refresh_rate(arg_rate: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.SetGpsRefreshRate">SetGpsRefreshRate()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_call_set_gps_refresh_rate_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_call_set_gps_refresh_rate_sync() for the synchronous, blocking version of this method.
             * @param arg_rate Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_gps_refresh_rate(
                arg_rate: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.SetGpsRefreshRate">SetGpsRefreshRate()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_call_set_gps_refresh_rate_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_call_set_gps_refresh_rate_sync() for the synchronous, blocking version of this method.
             * @param arg_rate Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_gps_refresh_rate(
                arg_rate: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_location_call_set_gps_refresh_rate().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_location_call_set_gps_refresh_rate().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_gps_refresh_rate_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.SetGpsRefreshRate">SetGpsRefreshRate()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_location_call_set_gps_refresh_rate() for the asynchronous version of this method.
             * @param arg_rate Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_gps_refresh_rate_sync(arg_rate: number, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.SetSuplServer">SetSuplServer()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_call_set_supl_server_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_call_set_supl_server_sync() for the synchronous, blocking version of this method.
             * @param arg_supl Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set_supl_server(arg_supl: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.SetSuplServer">SetSuplServer()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_call_set_supl_server_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_call_set_supl_server_sync() for the synchronous, blocking version of this method.
             * @param arg_supl Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_supl_server(
                arg_supl: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.SetSuplServer">SetSuplServer()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_call_set_supl_server_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_call_set_supl_server_sync() for the synchronous, blocking version of this method.
             * @param arg_supl Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_supl_server(
                arg_supl: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_location_call_set_supl_server().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_location_call_set_supl_server().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_supl_server_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.SetSuplServer">SetSuplServer()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_location_call_set_supl_server() for the asynchronous version of this method.
             * @param arg_supl Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_supl_server_sync(arg_supl: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.Setup">Setup()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_call_setup_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_call_setup_sync() for the synchronous, blocking version of this method.
             * @param arg_sources Argument to pass with the method invocation.
             * @param arg_signal_location Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_setup(
                arg_sources: number,
                arg_signal_location: boolean,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.Setup">Setup()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_call_setup_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_call_setup_sync() for the synchronous, blocking version of this method.
             * @param arg_sources Argument to pass with the method invocation.
             * @param arg_signal_location Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_setup(
                arg_sources: number,
                arg_signal_location: boolean,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.Setup">Setup()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_call_setup_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_call_setup_sync() for the synchronous, blocking version of this method.
             * @param arg_sources Argument to pass with the method invocation.
             * @param arg_signal_location Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_setup(
                arg_sources: number,
                arg_signal_location: boolean,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_location_call_setup().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_location_call_setup().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_setup_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.Setup">Setup()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_location_call_setup() for the asynchronous version of this method.
             * @param arg_sources Argument to pass with the method invocation.
             * @param arg_signal_location Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_setup_sync(
                arg_sources: number,
                arg_signal_location: boolean,
                cancellable?: Gio.Cancellable | null,
            ): boolean;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.GetLocation">GetLocation()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param Location Parameter to return.
             */
            complete_get_location(invocation: Gio.DBusMethodInvocation, Location: GLib.Variant): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.InjectAssistanceData">InjectAssistanceData()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_inject_assistance_data(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.SetGpsRefreshRate">SetGpsRefreshRate()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_set_gps_refresh_rate(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.SetSuplServer">SetSuplServer()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_set_supl_server(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.Setup">Setup()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_setup(invocation: Gio.DBusMethodInvocation): void;
            vfunc_handle_get_location(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_inject_assistance_data(invocation: Gio.DBusMethodInvocation, arg_data: GLib.Variant): boolean;
            vfunc_handle_set_gps_refresh_rate(invocation: Gio.DBusMethodInvocation, arg_rate: number): boolean;
            vfunc_handle_set_supl_server(invocation: Gio.DBusMethodInvocation, arg_supl: string): boolean;
            vfunc_handle_setup(
                invocation: Gio.DBusMethodInvocation,
                arg_sources: number,
                arg_signal_location: boolean,
            ): boolean;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace GdbusModemLocationSkeleton {
            // Constructor properties interface

            interface ConstructorProps
                extends Gio.DBusInterfaceSkeleton.ConstructorProps,
                    Gio.DBusInterface.ConstructorProps,
                    GdbusModemLocation.ConstructorProps {}
        }

        /**
         * The #MmGdbusModemLocationSkeleton structure contains only private data and should only be accessed using the provided API.
         */
        class GdbusModemLocationSkeleton
            extends Gio.DBusInterfaceSkeleton
            implements Gio.DBusInterface, GdbusModemLocation
        {
            static $gtype: GObject.GType<GdbusModemLocationSkeleton>;

            // Constructors

            constructor(properties?: Partial<GdbusModemLocationSkeleton.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static ['new'](): GdbusModemLocationSkeleton;

            // Inherited properties
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Location.AssistanceDataServers">"AssistanceDataServers"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get assistance_data_servers(): string[];
            set assistance_data_servers(val: string[]);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Location.AssistanceDataServers">"AssistanceDataServers"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get assistanceDataServers(): string[];
            set assistanceDataServers(val: string[]);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Location.Capabilities">"Capabilities"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get capabilities(): number;
            set capabilities(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Location.Enabled">"Enabled"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get enabled(): number;
            set enabled(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Location.GpsRefreshRate">"GpsRefreshRate"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get gps_refresh_rate(): number;
            set gps_refresh_rate(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Location.GpsRefreshRate">"GpsRefreshRate"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get gpsRefreshRate(): number;
            set gpsRefreshRate(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Location.Location">"Location"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get location(): GLib.Variant;
            set location(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Location.SignalsLocation">"SignalsLocation"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get signals_location(): boolean;
            set signals_location(val: boolean);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Location.SignalsLocation">"SignalsLocation"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get signalsLocation(): boolean;
            set signalsLocation(val: boolean);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Location.SuplServer">"SuplServer"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get supl_server(): string;
            set supl_server(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Location.SuplServer">"SuplServer"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get suplServer(): string;
            set suplServer(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Location.SupportedAssistanceData">"SupportedAssistanceData"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get supported_assistance_data(): number;
            set supported_assistance_data(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Location.SupportedAssistanceData">"SupportedAssistanceData"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get supportedAssistanceData(): number;
            set supportedAssistanceData(val: number);

            // Inherited methods
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             * @returns A #GDBusObject or %NULL. The returned reference should be freed with g_object_unref().
             */
            get_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             * @returns A #GDBusInterfaceInfo. Do not free.
             */
            get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            set_object(object?: Gio.DBusObject | null): void;
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             */
            vfunc_dup_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             */
            vfunc_get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            vfunc_set_object(object?: Gio.DBusObject | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.GetLocation">GetLocation()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_call_get_location_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_call_get_location_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_get_location(cancellable?: Gio.Cancellable | null): Promise<GLib.Variant | null>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.GetLocation">GetLocation()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_call_get_location_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_call_get_location_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_get_location(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.GetLocation">GetLocation()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_call_get_location_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_call_get_location_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_get_location(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<GLib.Variant | null> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_location_call_get_location().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_location_call_get_location().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_get_location_finish(res: Gio.AsyncResult): [boolean, GLib.Variant | null];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.GetLocation">GetLocation()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_location_call_get_location() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_get_location_sync(cancellable?: Gio.Cancellable | null): [boolean, GLib.Variant | null];
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.InjectAssistanceData">InjectAssistanceData()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_call_inject_assistance_data_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_call_inject_assistance_data_sync() for the synchronous, blocking version of this method.
             * @param arg_data Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_inject_assistance_data(arg_data: GLib.Variant, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.InjectAssistanceData">InjectAssistanceData()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_call_inject_assistance_data_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_call_inject_assistance_data_sync() for the synchronous, blocking version of this method.
             * @param arg_data Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_inject_assistance_data(
                arg_data: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.InjectAssistanceData">InjectAssistanceData()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_call_inject_assistance_data_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_call_inject_assistance_data_sync() for the synchronous, blocking version of this method.
             * @param arg_data Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_inject_assistance_data(
                arg_data: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_location_call_inject_assistance_data().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_location_call_inject_assistance_data().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_inject_assistance_data_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.InjectAssistanceData">InjectAssistanceData()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_location_call_inject_assistance_data() for the asynchronous version of this method.
             * @param arg_data Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_inject_assistance_data_sync(arg_data: GLib.Variant, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.SetGpsRefreshRate">SetGpsRefreshRate()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_call_set_gps_refresh_rate_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_call_set_gps_refresh_rate_sync() for the synchronous, blocking version of this method.
             * @param arg_rate Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set_gps_refresh_rate(arg_rate: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.SetGpsRefreshRate">SetGpsRefreshRate()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_call_set_gps_refresh_rate_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_call_set_gps_refresh_rate_sync() for the synchronous, blocking version of this method.
             * @param arg_rate Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_gps_refresh_rate(
                arg_rate: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.SetGpsRefreshRate">SetGpsRefreshRate()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_call_set_gps_refresh_rate_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_call_set_gps_refresh_rate_sync() for the synchronous, blocking version of this method.
             * @param arg_rate Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_gps_refresh_rate(
                arg_rate: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_location_call_set_gps_refresh_rate().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_location_call_set_gps_refresh_rate().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_gps_refresh_rate_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.SetGpsRefreshRate">SetGpsRefreshRate()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_location_call_set_gps_refresh_rate() for the asynchronous version of this method.
             * @param arg_rate Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_gps_refresh_rate_sync(arg_rate: number, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.SetSuplServer">SetSuplServer()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_call_set_supl_server_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_call_set_supl_server_sync() for the synchronous, blocking version of this method.
             * @param arg_supl Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set_supl_server(arg_supl: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.SetSuplServer">SetSuplServer()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_call_set_supl_server_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_call_set_supl_server_sync() for the synchronous, blocking version of this method.
             * @param arg_supl Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_supl_server(
                arg_supl: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.SetSuplServer">SetSuplServer()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_call_set_supl_server_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_call_set_supl_server_sync() for the synchronous, blocking version of this method.
             * @param arg_supl Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_supl_server(
                arg_supl: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_location_call_set_supl_server().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_location_call_set_supl_server().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_supl_server_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.SetSuplServer">SetSuplServer()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_location_call_set_supl_server() for the asynchronous version of this method.
             * @param arg_supl Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_supl_server_sync(arg_supl: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.Setup">Setup()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_call_setup_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_call_setup_sync() for the synchronous, blocking version of this method.
             * @param arg_sources Argument to pass with the method invocation.
             * @param arg_signal_location Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_setup(
                arg_sources: number,
                arg_signal_location: boolean,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.Setup">Setup()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_call_setup_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_call_setup_sync() for the synchronous, blocking version of this method.
             * @param arg_sources Argument to pass with the method invocation.
             * @param arg_signal_location Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_setup(
                arg_sources: number,
                arg_signal_location: boolean,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.Setup">Setup()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_call_setup_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_call_setup_sync() for the synchronous, blocking version of this method.
             * @param arg_sources Argument to pass with the method invocation.
             * @param arg_signal_location Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_setup(
                arg_sources: number,
                arg_signal_location: boolean,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_location_call_setup().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_location_call_setup().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_setup_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.Setup">Setup()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_location_call_setup() for the asynchronous version of this method.
             * @param arg_sources Argument to pass with the method invocation.
             * @param arg_signal_location Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_setup_sync(
                arg_sources: number,
                arg_signal_location: boolean,
                cancellable?: Gio.Cancellable | null,
            ): boolean;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.GetLocation">GetLocation()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param Location Parameter to return.
             */
            complete_get_location(invocation: Gio.DBusMethodInvocation, Location: GLib.Variant): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.InjectAssistanceData">InjectAssistanceData()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_inject_assistance_data(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.SetGpsRefreshRate">SetGpsRefreshRate()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_set_gps_refresh_rate(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.SetSuplServer">SetSuplServer()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_set_supl_server(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.Setup">Setup()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_setup(invocation: Gio.DBusMethodInvocation): void;
            vfunc_handle_get_location(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_inject_assistance_data(invocation: Gio.DBusMethodInvocation, arg_data: GLib.Variant): boolean;
            vfunc_handle_set_gps_refresh_rate(invocation: Gio.DBusMethodInvocation, arg_rate: number): boolean;
            vfunc_handle_set_supl_server(invocation: Gio.DBusMethodInvocation, arg_supl: string): boolean;
            vfunc_handle_setup(
                invocation: Gio.DBusMethodInvocation,
                arg_sources: number,
                arg_signal_location: boolean,
            ): boolean;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace GdbusModemMessagingProxy {
            // Constructor properties interface

            interface ConstructorProps
                extends Gio.DBusProxy.ConstructorProps,
                    Gio.AsyncInitable.ConstructorProps,
                    Gio.DBusInterface.ConstructorProps,
                    Gio.Initable.ConstructorProps,
                    GdbusModemMessaging.ConstructorProps {}
        }

        /**
         * The #MmGdbusModemMessagingProxy structure contains only private data and should only be accessed using the provided API.
         */
        class GdbusModemMessagingProxy
            extends Gio.DBusProxy
            implements Gio.AsyncInitable<GdbusModemMessagingProxy>, Gio.DBusInterface, Gio.Initable, GdbusModemMessaging
        {
            static $gtype: GObject.GType<GdbusModemMessagingProxy>;

            // Constructors

            constructor(properties?: Partial<GdbusModemMessagingProxy.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static new_finish(res: Gio.AsyncResult): GdbusModemMessagingProxy;
            // Conflicted with Gio.AsyncInitable.new_finish

            static new_finish(...args: never[]): any;

            static new_for_bus_finish(res: Gio.AsyncResult): GdbusModemMessagingProxy;

            static new_for_bus_sync(
                bus_type: Gio.BusType,
                flags: Gio.DBusProxyFlags,
                name: string,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
            ): GdbusModemMessagingProxy;
            // Conflicted with Gio.DBusProxy.new_for_bus_sync

            static new_for_bus_sync(...args: never[]): any;

            static new_sync(
                connection: Gio.DBusConnection,
                flags: Gio.DBusProxyFlags,
                name: string | null,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
            ): GdbusModemMessagingProxy;
            // Conflicted with Gio.DBusProxy.new_sync

            static new_sync(...args: never[]): any;

            // Static methods

            /**
             * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Messaging.top_of_page">org.freedesktop.ModemManager1.Modem.Messaging</link>. See g_dbus_proxy_new() for more details.
             *
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_messaging_proxy_new_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_messaging_proxy_new_sync() for the synchronous, blocking version of this constructor.
             * @param connection A #GDBusConnection.
             * @param flags Flags from the #GDBusProxyFlags enumeration.
             * @param name A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
             * @param object_path An object path.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied.
             */
            static ['new'](
                connection: Gio.DBusConnection,
                flags: Gio.DBusProxyFlags,
                name: string | null,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<GdbusModemMessagingProxy> | null,
            ): void;
            // Conflicted with Gio.DBusProxy.new
            static ['new'](...args: never[]): any;
            /**
             * Like mm_gdbus_modem_messaging_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
             *
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_messaging_proxy_new_for_bus_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_messaging_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
             * @param bus_type A #GBusType.
             * @param flags Flags from the #GDBusProxyFlags enumeration.
             * @param name A bus name (well-known or unique).
             * @param object_path An object path.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied.
             */
            static new_for_bus(
                bus_type: Gio.BusType,
                flags: Gio.DBusProxyFlags,
                name: string,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<GdbusModemMessagingProxy> | null,
            ): void;
            // Conflicted with Gio.DBusProxy.new_for_bus
            static new_for_bus(...args: never[]): any;

            // Inherited properties
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Messaging.DefaultStorage">"DefaultStorage"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get default_storage(): number;
            set default_storage(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Messaging.DefaultStorage">"DefaultStorage"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get defaultStorage(): number;
            set defaultStorage(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Messaging.Messages">"Messages"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get messages(): string[];
            set messages(val: string[]);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Messaging.SupportedStorages">"SupportedStorages"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get supported_storages(): GLib.Variant;
            set supported_storages(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Messaging.SupportedStorages">"SupportedStorages"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get supportedStorages(): GLib.Variant;
            set supportedStorages(val: GLib.Variant);

            // Inherited methods
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            init_async(io_priority: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             * @returns %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present.
             */
            init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Finishes the async construction for the various g_async_initable_new
             * calls, returning the created object or %NULL on error.
             * @param res the #GAsyncResult from the callback
             * @returns a newly created #GObject,      or %NULL on error. Free with g_object_unref().
             */
            new_finish(res: Gio.AsyncResult): GdbusModemMessagingProxy;
            // Conflicted with Gio.DBusProxy.new_finish
            new_finish(...args: never[]): any;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            vfunc_init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             */
            vfunc_init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             * @returns A #GDBusObject or %NULL. The returned reference should be freed with g_object_unref().
             */
            get_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             * @returns A #GDBusInterfaceInfo. Do not free.
             */
            get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            set_object(object?: Gio.DBusObject | null): void;
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             */
            vfunc_dup_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             */
            vfunc_get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            vfunc_set_object(object?: Gio.DBusObject | null): void;
            /**
             * Initializes the object implementing the interface.
             *
             * This method is intended for language bindings. If writing in C,
             * g_initable_new() should typically be used instead.
             *
             * The object must be initialized before any real use after initial
             * construction, either with this function or g_async_initable_init_async().
             *
             * Implementations may also support cancellation. If `cancellable` is not %NULL,
             * then initialization can be cancelled by triggering the cancellable object
             * from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
             * the object doesn't support cancellable initialization the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * If the object is not initialized, or initialization returns with an
             * error, then all operations on the object except g_object_ref() and
             * g_object_unref() are considered to be invalid, and have undefined
             * behaviour. See the [description][iface`Gio`.Initable#description] for more details.
             *
             * Callers should not assume that a class which implements #GInitable can be
             * initialized multiple times, unless the class explicitly documents itself as
             * supporting this. Generally, a class’ implementation of init() can assume
             * (and assert) that it will only be called once. Previously, this documentation
             * recommended all #GInitable implementations should be idempotent; that
             * recommendation was relaxed in GLib 2.54.
             *
             * If a class explicitly supports being initialized multiple times, it is
             * recommended that the method is idempotent: multiple calls with the same
             * arguments should return the same results. Only the first call initializes
             * the object; further calls return the result of the first call.
             *
             * One reason why a class might need to support idempotent initialization is if
             * it is designed to be used via the singleton pattern, with a
             * #GObjectClass.constructor that sometimes returns an existing instance.
             * In this pattern, a caller would expect to be able to call g_initable_init()
             * on the result of g_object_new(), regardless of whether it is in fact a new
             * instance.
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @returns %TRUE if successful. If an error has occurred, this function will     return %FALSE and set @error appropriately if present.
             */
            init(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Initializes the object implementing the interface.
             *
             * This method is intended for language bindings. If writing in C,
             * g_initable_new() should typically be used instead.
             *
             * The object must be initialized before any real use after initial
             * construction, either with this function or g_async_initable_init_async().
             *
             * Implementations may also support cancellation. If `cancellable` is not %NULL,
             * then initialization can be cancelled by triggering the cancellable object
             * from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
             * the object doesn't support cancellable initialization the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * If the object is not initialized, or initialization returns with an
             * error, then all operations on the object except g_object_ref() and
             * g_object_unref() are considered to be invalid, and have undefined
             * behaviour. See the [description][iface`Gio`.Initable#description] for more details.
             *
             * Callers should not assume that a class which implements #GInitable can be
             * initialized multiple times, unless the class explicitly documents itself as
             * supporting this. Generally, a class’ implementation of init() can assume
             * (and assert) that it will only be called once. Previously, this documentation
             * recommended all #GInitable implementations should be idempotent; that
             * recommendation was relaxed in GLib 2.54.
             *
             * If a class explicitly supports being initialized multiple times, it is
             * recommended that the method is idempotent: multiple calls with the same
             * arguments should return the same results. Only the first call initializes
             * the object; further calls return the result of the first call.
             *
             * One reason why a class might need to support idempotent initialization is if
             * it is designed to be used via the singleton pattern, with a
             * #GObjectClass.constructor that sometimes returns an existing instance.
             * In this pattern, a caller would expect to be able to call g_initable_init()
             * on the result of g_object_new(), regardless of whether it is in fact a new
             * instance.
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            vfunc_init(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Messaging.Create">Create()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_messaging_call_create_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_messaging_call_create_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_create(arg_properties: GLib.Variant, cancellable?: Gio.Cancellable | null): Promise<string>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Messaging.Create">Create()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_messaging_call_create_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_messaging_call_create_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_create(
                arg_properties: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Messaging.Create">Create()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_messaging_call_create_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_messaging_call_create_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_create(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<string> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_messaging_call_create().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_messaging_call_create().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_create_finish(res: Gio.AsyncResult): [boolean, string];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Messaging.Create">Create()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_messaging_call_create() for the asynchronous version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_create_sync(arg_properties: GLib.Variant, cancellable?: Gio.Cancellable | null): [boolean, string];
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Messaging.Delete">Delete()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_messaging_call_delete_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_messaging_call_delete_sync() for the synchronous, blocking version of this method.
             * @param arg_path Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_delete(arg_path: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Messaging.Delete">Delete()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_messaging_call_delete_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_messaging_call_delete_sync() for the synchronous, blocking version of this method.
             * @param arg_path Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_delete(
                arg_path: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Messaging.Delete">Delete()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_messaging_call_delete_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_messaging_call_delete_sync() for the synchronous, blocking version of this method.
             * @param arg_path Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_delete(
                arg_path: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_messaging_call_delete().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_messaging_call_delete().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_delete_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Messaging.Delete">Delete()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_messaging_call_delete() for the asynchronous version of this method.
             * @param arg_path Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_delete_sync(arg_path: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Messaging.List">List()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_messaging_call_list_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_messaging_call_list_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_list(cancellable?: Gio.Cancellable | null): Promise<string[] | null>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Messaging.List">List()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_messaging_call_list_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_messaging_call_list_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_list(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Messaging.List">List()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_messaging_call_list_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_messaging_call_list_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_list(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<string[] | null> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_messaging_call_list().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_messaging_call_list().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_list_finish(res: Gio.AsyncResult): [boolean, string[] | null];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Messaging.List">List()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_messaging_call_list() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_list_sync(cancellable?: Gio.Cancellable | null): [boolean, string[] | null];
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Messaging.Create">Create()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param path Parameter to return.
             */
            complete_create(invocation: Gio.DBusMethodInvocation, path: string): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Messaging.Delete">Delete()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_delete(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Messaging.List">List()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param result Parameter to return.
             */
            complete_list(invocation: Gio.DBusMethodInvocation, result: string): void;
            /**
             * Emits the <link linkend="gdbus-signal-org-freedesktop-ModemManager1-Modem-Messaging.Added">"Added"</link> D-Bus signal.
             * @param arg_path Argument to pass with the signal.
             * @param arg_received Argument to pass with the signal.
             */
            emit_added(arg_path: string, arg_received: boolean): void;
            /**
             * Emits the <link linkend="gdbus-signal-org-freedesktop-ModemManager1-Modem-Messaging.Deleted">"Deleted"</link> D-Bus signal.
             * @param arg_path Argument to pass with the signal.
             */
            emit_deleted(arg_path: string): void;
            vfunc_added(arg_path: string, arg_received: boolean): void;
            vfunc_deleted(arg_path: string): void;
            vfunc_handle_create(invocation: Gio.DBusMethodInvocation, arg_properties: GLib.Variant): boolean;
            vfunc_handle_delete(invocation: Gio.DBusMethodInvocation, arg_path: string): boolean;
            vfunc_handle_list(invocation: Gio.DBusMethodInvocation): boolean;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace GdbusModemMessagingSkeleton {
            // Constructor properties interface

            interface ConstructorProps
                extends Gio.DBusInterfaceSkeleton.ConstructorProps,
                    Gio.DBusInterface.ConstructorProps,
                    GdbusModemMessaging.ConstructorProps {}
        }

        /**
         * The #MmGdbusModemMessagingSkeleton structure contains only private data and should only be accessed using the provided API.
         */
        class GdbusModemMessagingSkeleton
            extends Gio.DBusInterfaceSkeleton
            implements Gio.DBusInterface, GdbusModemMessaging
        {
            static $gtype: GObject.GType<GdbusModemMessagingSkeleton>;

            // Constructors

            constructor(properties?: Partial<GdbusModemMessagingSkeleton.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static ['new'](): GdbusModemMessagingSkeleton;

            // Inherited properties
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Messaging.DefaultStorage">"DefaultStorage"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get default_storage(): number;
            set default_storage(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Messaging.DefaultStorage">"DefaultStorage"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get defaultStorage(): number;
            set defaultStorage(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Messaging.Messages">"Messages"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get messages(): string[];
            set messages(val: string[]);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Messaging.SupportedStorages">"SupportedStorages"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get supported_storages(): GLib.Variant;
            set supported_storages(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Messaging.SupportedStorages">"SupportedStorages"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get supportedStorages(): GLib.Variant;
            set supportedStorages(val: GLib.Variant);

            // Inherited methods
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             * @returns A #GDBusObject or %NULL. The returned reference should be freed with g_object_unref().
             */
            get_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             * @returns A #GDBusInterfaceInfo. Do not free.
             */
            get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            set_object(object?: Gio.DBusObject | null): void;
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             */
            vfunc_dup_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             */
            vfunc_get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            vfunc_set_object(object?: Gio.DBusObject | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Messaging.Create">Create()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_messaging_call_create_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_messaging_call_create_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_create(arg_properties: GLib.Variant, cancellable?: Gio.Cancellable | null): Promise<string>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Messaging.Create">Create()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_messaging_call_create_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_messaging_call_create_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_create(
                arg_properties: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Messaging.Create">Create()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_messaging_call_create_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_messaging_call_create_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_create(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<string> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_messaging_call_create().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_messaging_call_create().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_create_finish(res: Gio.AsyncResult): [boolean, string];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Messaging.Create">Create()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_messaging_call_create() for the asynchronous version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_create_sync(arg_properties: GLib.Variant, cancellable?: Gio.Cancellable | null): [boolean, string];
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Messaging.Delete">Delete()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_messaging_call_delete_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_messaging_call_delete_sync() for the synchronous, blocking version of this method.
             * @param arg_path Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_delete(arg_path: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Messaging.Delete">Delete()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_messaging_call_delete_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_messaging_call_delete_sync() for the synchronous, blocking version of this method.
             * @param arg_path Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_delete(
                arg_path: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Messaging.Delete">Delete()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_messaging_call_delete_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_messaging_call_delete_sync() for the synchronous, blocking version of this method.
             * @param arg_path Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_delete(
                arg_path: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_messaging_call_delete().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_messaging_call_delete().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_delete_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Messaging.Delete">Delete()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_messaging_call_delete() for the asynchronous version of this method.
             * @param arg_path Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_delete_sync(arg_path: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Messaging.List">List()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_messaging_call_list_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_messaging_call_list_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_list(cancellable?: Gio.Cancellable | null): Promise<string[] | null>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Messaging.List">List()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_messaging_call_list_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_messaging_call_list_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_list(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Messaging.List">List()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_messaging_call_list_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_messaging_call_list_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_list(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<string[] | null> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_messaging_call_list().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_messaging_call_list().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_list_finish(res: Gio.AsyncResult): [boolean, string[] | null];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Messaging.List">List()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_messaging_call_list() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_list_sync(cancellable?: Gio.Cancellable | null): [boolean, string[] | null];
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Messaging.Create">Create()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param path Parameter to return.
             */
            complete_create(invocation: Gio.DBusMethodInvocation, path: string): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Messaging.Delete">Delete()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_delete(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Messaging.List">List()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param result Parameter to return.
             */
            complete_list(invocation: Gio.DBusMethodInvocation, result: string): void;
            /**
             * Emits the <link linkend="gdbus-signal-org-freedesktop-ModemManager1-Modem-Messaging.Added">"Added"</link> D-Bus signal.
             * @param arg_path Argument to pass with the signal.
             * @param arg_received Argument to pass with the signal.
             */
            emit_added(arg_path: string, arg_received: boolean): void;
            /**
             * Emits the <link linkend="gdbus-signal-org-freedesktop-ModemManager1-Modem-Messaging.Deleted">"Deleted"</link> D-Bus signal.
             * @param arg_path Argument to pass with the signal.
             */
            emit_deleted(arg_path: string): void;
            vfunc_added(arg_path: string, arg_received: boolean): void;
            vfunc_deleted(arg_path: string): void;
            vfunc_handle_create(invocation: Gio.DBusMethodInvocation, arg_properties: GLib.Variant): boolean;
            vfunc_handle_delete(invocation: Gio.DBusMethodInvocation, arg_path: string): boolean;
            vfunc_handle_list(invocation: Gio.DBusMethodInvocation): boolean;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace GdbusModemOmaProxy {
            // Constructor properties interface

            interface ConstructorProps
                extends Gio.DBusProxy.ConstructorProps,
                    Gio.AsyncInitable.ConstructorProps,
                    Gio.DBusInterface.ConstructorProps,
                    Gio.Initable.ConstructorProps,
                    GdbusModemOma.ConstructorProps {}
        }

        /**
         * The #MmGdbusModemOmaProxy structure contains only private data and should only be accessed using the provided API.
         */
        class GdbusModemOmaProxy
            extends Gio.DBusProxy
            implements Gio.AsyncInitable<GdbusModemOmaProxy>, Gio.DBusInterface, Gio.Initable, GdbusModemOma
        {
            static $gtype: GObject.GType<GdbusModemOmaProxy>;

            // Constructors

            constructor(properties?: Partial<GdbusModemOmaProxy.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static new_finish(res: Gio.AsyncResult): GdbusModemOmaProxy;
            // Conflicted with Gio.AsyncInitable.new_finish

            static new_finish(...args: never[]): any;

            static new_for_bus_finish(res: Gio.AsyncResult): GdbusModemOmaProxy;

            static new_for_bus_sync(
                bus_type: Gio.BusType,
                flags: Gio.DBusProxyFlags,
                name: string,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
            ): GdbusModemOmaProxy;
            // Conflicted with Gio.DBusProxy.new_for_bus_sync

            static new_for_bus_sync(...args: never[]): any;

            static new_sync(
                connection: Gio.DBusConnection,
                flags: Gio.DBusProxyFlags,
                name: string | null,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
            ): GdbusModemOmaProxy;
            // Conflicted with Gio.DBusProxy.new_sync

            static new_sync(...args: never[]): any;

            // Static methods

            /**
             * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Oma.top_of_page">org.freedesktop.ModemManager1.Modem.Oma</link>. See g_dbus_proxy_new() for more details.
             *
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_oma_proxy_new_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_oma_proxy_new_sync() for the synchronous, blocking version of this constructor.
             * @param connection A #GDBusConnection.
             * @param flags Flags from the #GDBusProxyFlags enumeration.
             * @param name A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
             * @param object_path An object path.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied.
             */
            static ['new'](
                connection: Gio.DBusConnection,
                flags: Gio.DBusProxyFlags,
                name: string | null,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<GdbusModemOmaProxy> | null,
            ): void;
            // Conflicted with Gio.DBusProxy.new
            static ['new'](...args: never[]): any;
            /**
             * Like mm_gdbus_modem_oma_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
             *
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_oma_proxy_new_for_bus_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_oma_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
             * @param bus_type A #GBusType.
             * @param flags Flags from the #GDBusProxyFlags enumeration.
             * @param name A bus name (well-known or unique).
             * @param object_path An object path.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied.
             */
            static new_for_bus(
                bus_type: Gio.BusType,
                flags: Gio.DBusProxyFlags,
                name: string,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<GdbusModemOmaProxy> | null,
            ): void;
            // Conflicted with Gio.DBusProxy.new_for_bus
            static new_for_bus(...args: never[]): any;

            // Inherited properties
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Oma.Features">"Features"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get features(): number;
            set features(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Oma.PendingNetworkInitiatedSessions">"PendingNetworkInitiatedSessions"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get pending_network_initiated_sessions(): GLib.Variant;
            set pending_network_initiated_sessions(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Oma.PendingNetworkInitiatedSessions">"PendingNetworkInitiatedSessions"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get pendingNetworkInitiatedSessions(): GLib.Variant;
            set pendingNetworkInitiatedSessions(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Oma.SessionState">"SessionState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get session_state(): number;
            set session_state(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Oma.SessionState">"SessionState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get sessionState(): number;
            set sessionState(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Oma.SessionType">"SessionType"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get session_type(): number;
            set session_type(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Oma.SessionType">"SessionType"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get sessionType(): number;
            set sessionType(val: number);

            // Inherited methods
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            init_async(io_priority: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             * @returns %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present.
             */
            init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Finishes the async construction for the various g_async_initable_new
             * calls, returning the created object or %NULL on error.
             * @param res the #GAsyncResult from the callback
             * @returns a newly created #GObject,      or %NULL on error. Free with g_object_unref().
             */
            new_finish(res: Gio.AsyncResult): GdbusModemOmaProxy;
            // Conflicted with Gio.DBusProxy.new_finish
            new_finish(...args: never[]): any;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            vfunc_init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             */
            vfunc_init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             * @returns A #GDBusObject or %NULL. The returned reference should be freed with g_object_unref().
             */
            get_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             * @returns A #GDBusInterfaceInfo. Do not free.
             */
            get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            set_object(object?: Gio.DBusObject | null): void;
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             */
            vfunc_dup_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             */
            vfunc_get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            vfunc_set_object(object?: Gio.DBusObject | null): void;
            /**
             * Initializes the object implementing the interface.
             *
             * This method is intended for language bindings. If writing in C,
             * g_initable_new() should typically be used instead.
             *
             * The object must be initialized before any real use after initial
             * construction, either with this function or g_async_initable_init_async().
             *
             * Implementations may also support cancellation. If `cancellable` is not %NULL,
             * then initialization can be cancelled by triggering the cancellable object
             * from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
             * the object doesn't support cancellable initialization the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * If the object is not initialized, or initialization returns with an
             * error, then all operations on the object except g_object_ref() and
             * g_object_unref() are considered to be invalid, and have undefined
             * behaviour. See the [description][iface`Gio`.Initable#description] for more details.
             *
             * Callers should not assume that a class which implements #GInitable can be
             * initialized multiple times, unless the class explicitly documents itself as
             * supporting this. Generally, a class’ implementation of init() can assume
             * (and assert) that it will only be called once. Previously, this documentation
             * recommended all #GInitable implementations should be idempotent; that
             * recommendation was relaxed in GLib 2.54.
             *
             * If a class explicitly supports being initialized multiple times, it is
             * recommended that the method is idempotent: multiple calls with the same
             * arguments should return the same results. Only the first call initializes
             * the object; further calls return the result of the first call.
             *
             * One reason why a class might need to support idempotent initialization is if
             * it is designed to be used via the singleton pattern, with a
             * #GObjectClass.constructor that sometimes returns an existing instance.
             * In this pattern, a caller would expect to be able to call g_initable_init()
             * on the result of g_object_new(), regardless of whether it is in fact a new
             * instance.
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @returns %TRUE if successful. If an error has occurred, this function will     return %FALSE and set @error appropriately if present.
             */
            init(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Initializes the object implementing the interface.
             *
             * This method is intended for language bindings. If writing in C,
             * g_initable_new() should typically be used instead.
             *
             * The object must be initialized before any real use after initial
             * construction, either with this function or g_async_initable_init_async().
             *
             * Implementations may also support cancellation. If `cancellable` is not %NULL,
             * then initialization can be cancelled by triggering the cancellable object
             * from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
             * the object doesn't support cancellable initialization the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * If the object is not initialized, or initialization returns with an
             * error, then all operations on the object except g_object_ref() and
             * g_object_unref() are considered to be invalid, and have undefined
             * behaviour. See the [description][iface`Gio`.Initable#description] for more details.
             *
             * Callers should not assume that a class which implements #GInitable can be
             * initialized multiple times, unless the class explicitly documents itself as
             * supporting this. Generally, a class’ implementation of init() can assume
             * (and assert) that it will only be called once. Previously, this documentation
             * recommended all #GInitable implementations should be idempotent; that
             * recommendation was relaxed in GLib 2.54.
             *
             * If a class explicitly supports being initialized multiple times, it is
             * recommended that the method is idempotent: multiple calls with the same
             * arguments should return the same results. Only the first call initializes
             * the object; further calls return the result of the first call.
             *
             * One reason why a class might need to support idempotent initialization is if
             * it is designed to be used via the singleton pattern, with a
             * #GObjectClass.constructor that sometimes returns an existing instance.
             * In this pattern, a caller would expect to be able to call g_initable_init()
             * on the result of g_object_new(), regardless of whether it is in fact a new
             * instance.
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            vfunc_init(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.AcceptNetworkInitiatedSession">AcceptNetworkInitiatedSession()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_oma_call_accept_network_initiated_session_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_oma_call_accept_network_initiated_session_sync() for the synchronous, blocking version of this method.
             * @param arg_session_id Argument to pass with the method invocation.
             * @param arg_accept Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_accept_network_initiated_session(
                arg_session_id: number,
                arg_accept: boolean,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.AcceptNetworkInitiatedSession">AcceptNetworkInitiatedSession()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_oma_call_accept_network_initiated_session_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_oma_call_accept_network_initiated_session_sync() for the synchronous, blocking version of this method.
             * @param arg_session_id Argument to pass with the method invocation.
             * @param arg_accept Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_accept_network_initiated_session(
                arg_session_id: number,
                arg_accept: boolean,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.AcceptNetworkInitiatedSession">AcceptNetworkInitiatedSession()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_oma_call_accept_network_initiated_session_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_oma_call_accept_network_initiated_session_sync() for the synchronous, blocking version of this method.
             * @param arg_session_id Argument to pass with the method invocation.
             * @param arg_accept Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_accept_network_initiated_session(
                arg_session_id: number,
                arg_accept: boolean,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_oma_call_accept_network_initiated_session().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_oma_call_accept_network_initiated_session().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_accept_network_initiated_session_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.AcceptNetworkInitiatedSession">AcceptNetworkInitiatedSession()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_oma_call_accept_network_initiated_session() for the asynchronous version of this method.
             * @param arg_session_id Argument to pass with the method invocation.
             * @param arg_accept Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_accept_network_initiated_session_sync(
                arg_session_id: number,
                arg_accept: boolean,
                cancellable?: Gio.Cancellable | null,
            ): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.CancelSession">CancelSession()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_oma_call_cancel_session_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_oma_call_cancel_session_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_cancel_session(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.CancelSession">CancelSession()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_oma_call_cancel_session_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_oma_call_cancel_session_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_cancel_session(
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.CancelSession">CancelSession()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_oma_call_cancel_session_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_oma_call_cancel_session_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_cancel_session(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_oma_call_cancel_session().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_oma_call_cancel_session().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_cancel_session_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.CancelSession">CancelSession()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_oma_call_cancel_session() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_cancel_session_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.Setup">Setup()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_oma_call_setup_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_oma_call_setup_sync() for the synchronous, blocking version of this method.
             * @param arg_features Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_setup(arg_features: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.Setup">Setup()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_oma_call_setup_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_oma_call_setup_sync() for the synchronous, blocking version of this method.
             * @param arg_features Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_setup(
                arg_features: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.Setup">Setup()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_oma_call_setup_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_oma_call_setup_sync() for the synchronous, blocking version of this method.
             * @param arg_features Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_setup(
                arg_features: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_oma_call_setup().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_oma_call_setup().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_setup_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.Setup">Setup()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_oma_call_setup() for the asynchronous version of this method.
             * @param arg_features Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_setup_sync(arg_features: number, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.StartClientInitiatedSession">StartClientInitiatedSession()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_oma_call_start_client_initiated_session_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_oma_call_start_client_initiated_session_sync() for the synchronous, blocking version of this method.
             * @param arg_session_type Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_start_client_initiated_session(
                arg_session_type: number,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.StartClientInitiatedSession">StartClientInitiatedSession()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_oma_call_start_client_initiated_session_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_oma_call_start_client_initiated_session_sync() for the synchronous, blocking version of this method.
             * @param arg_session_type Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_start_client_initiated_session(
                arg_session_type: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.StartClientInitiatedSession">StartClientInitiatedSession()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_oma_call_start_client_initiated_session_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_oma_call_start_client_initiated_session_sync() for the synchronous, blocking version of this method.
             * @param arg_session_type Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_start_client_initiated_session(
                arg_session_type: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_oma_call_start_client_initiated_session().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_oma_call_start_client_initiated_session().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_start_client_initiated_session_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.StartClientInitiatedSession">StartClientInitiatedSession()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_oma_call_start_client_initiated_session() for the asynchronous version of this method.
             * @param arg_session_type Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_start_client_initiated_session_sync(
                arg_session_type: number,
                cancellable?: Gio.Cancellable | null,
            ): boolean;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.AcceptNetworkInitiatedSession">AcceptNetworkInitiatedSession()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_accept_network_initiated_session(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.CancelSession">CancelSession()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_cancel_session(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.Setup">Setup()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_setup(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.StartClientInitiatedSession">StartClientInitiatedSession()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_start_client_initiated_session(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Emits the <link linkend="gdbus-signal-org-freedesktop-ModemManager1-Modem-Oma.SessionStateChanged">"SessionStateChanged"</link> D-Bus signal.
             * @param arg_old_session_state Argument to pass with the signal.
             * @param arg_new_session_state Argument to pass with the signal.
             * @param arg_session_state_failed_reason Argument to pass with the signal.
             */
            emit_session_state_changed(
                arg_old_session_state: number,
                arg_new_session_state: number,
                arg_session_state_failed_reason: number,
            ): void;
            vfunc_handle_accept_network_initiated_session(
                invocation: Gio.DBusMethodInvocation,
                arg_session_id: number,
                arg_accept: boolean,
            ): boolean;
            vfunc_handle_cancel_session(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_setup(invocation: Gio.DBusMethodInvocation, arg_features: number): boolean;
            vfunc_handle_start_client_initiated_session(
                invocation: Gio.DBusMethodInvocation,
                arg_session_type: number,
            ): boolean;
            vfunc_session_state_changed(
                arg_old_session_state: number,
                arg_new_session_state: number,
                arg_session_state_failed_reason: number,
            ): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace GdbusModemOmaSkeleton {
            // Constructor properties interface

            interface ConstructorProps
                extends Gio.DBusInterfaceSkeleton.ConstructorProps,
                    Gio.DBusInterface.ConstructorProps,
                    GdbusModemOma.ConstructorProps {}
        }

        /**
         * The #MmGdbusModemOmaSkeleton structure contains only private data and should only be accessed using the provided API.
         */
        class GdbusModemOmaSkeleton extends Gio.DBusInterfaceSkeleton implements Gio.DBusInterface, GdbusModemOma {
            static $gtype: GObject.GType<GdbusModemOmaSkeleton>;

            // Constructors

            constructor(properties?: Partial<GdbusModemOmaSkeleton.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static ['new'](): GdbusModemOmaSkeleton;

            // Inherited properties
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Oma.Features">"Features"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get features(): number;
            set features(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Oma.PendingNetworkInitiatedSessions">"PendingNetworkInitiatedSessions"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get pending_network_initiated_sessions(): GLib.Variant;
            set pending_network_initiated_sessions(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Oma.PendingNetworkInitiatedSessions">"PendingNetworkInitiatedSessions"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get pendingNetworkInitiatedSessions(): GLib.Variant;
            set pendingNetworkInitiatedSessions(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Oma.SessionState">"SessionState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get session_state(): number;
            set session_state(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Oma.SessionState">"SessionState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get sessionState(): number;
            set sessionState(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Oma.SessionType">"SessionType"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get session_type(): number;
            set session_type(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Oma.SessionType">"SessionType"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get sessionType(): number;
            set sessionType(val: number);

            // Inherited methods
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             * @returns A #GDBusObject or %NULL. The returned reference should be freed with g_object_unref().
             */
            get_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             * @returns A #GDBusInterfaceInfo. Do not free.
             */
            get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            set_object(object?: Gio.DBusObject | null): void;
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             */
            vfunc_dup_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             */
            vfunc_get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            vfunc_set_object(object?: Gio.DBusObject | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.AcceptNetworkInitiatedSession">AcceptNetworkInitiatedSession()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_oma_call_accept_network_initiated_session_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_oma_call_accept_network_initiated_session_sync() for the synchronous, blocking version of this method.
             * @param arg_session_id Argument to pass with the method invocation.
             * @param arg_accept Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_accept_network_initiated_session(
                arg_session_id: number,
                arg_accept: boolean,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.AcceptNetworkInitiatedSession">AcceptNetworkInitiatedSession()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_oma_call_accept_network_initiated_session_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_oma_call_accept_network_initiated_session_sync() for the synchronous, blocking version of this method.
             * @param arg_session_id Argument to pass with the method invocation.
             * @param arg_accept Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_accept_network_initiated_session(
                arg_session_id: number,
                arg_accept: boolean,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.AcceptNetworkInitiatedSession">AcceptNetworkInitiatedSession()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_oma_call_accept_network_initiated_session_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_oma_call_accept_network_initiated_session_sync() for the synchronous, blocking version of this method.
             * @param arg_session_id Argument to pass with the method invocation.
             * @param arg_accept Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_accept_network_initiated_session(
                arg_session_id: number,
                arg_accept: boolean,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_oma_call_accept_network_initiated_session().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_oma_call_accept_network_initiated_session().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_accept_network_initiated_session_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.AcceptNetworkInitiatedSession">AcceptNetworkInitiatedSession()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_oma_call_accept_network_initiated_session() for the asynchronous version of this method.
             * @param arg_session_id Argument to pass with the method invocation.
             * @param arg_accept Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_accept_network_initiated_session_sync(
                arg_session_id: number,
                arg_accept: boolean,
                cancellable?: Gio.Cancellable | null,
            ): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.CancelSession">CancelSession()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_oma_call_cancel_session_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_oma_call_cancel_session_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_cancel_session(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.CancelSession">CancelSession()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_oma_call_cancel_session_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_oma_call_cancel_session_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_cancel_session(
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.CancelSession">CancelSession()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_oma_call_cancel_session_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_oma_call_cancel_session_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_cancel_session(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_oma_call_cancel_session().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_oma_call_cancel_session().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_cancel_session_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.CancelSession">CancelSession()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_oma_call_cancel_session() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_cancel_session_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.Setup">Setup()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_oma_call_setup_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_oma_call_setup_sync() for the synchronous, blocking version of this method.
             * @param arg_features Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_setup(arg_features: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.Setup">Setup()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_oma_call_setup_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_oma_call_setup_sync() for the synchronous, blocking version of this method.
             * @param arg_features Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_setup(
                arg_features: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.Setup">Setup()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_oma_call_setup_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_oma_call_setup_sync() for the synchronous, blocking version of this method.
             * @param arg_features Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_setup(
                arg_features: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_oma_call_setup().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_oma_call_setup().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_setup_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.Setup">Setup()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_oma_call_setup() for the asynchronous version of this method.
             * @param arg_features Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_setup_sync(arg_features: number, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.StartClientInitiatedSession">StartClientInitiatedSession()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_oma_call_start_client_initiated_session_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_oma_call_start_client_initiated_session_sync() for the synchronous, blocking version of this method.
             * @param arg_session_type Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_start_client_initiated_session(
                arg_session_type: number,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.StartClientInitiatedSession">StartClientInitiatedSession()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_oma_call_start_client_initiated_session_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_oma_call_start_client_initiated_session_sync() for the synchronous, blocking version of this method.
             * @param arg_session_type Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_start_client_initiated_session(
                arg_session_type: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.StartClientInitiatedSession">StartClientInitiatedSession()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_oma_call_start_client_initiated_session_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_oma_call_start_client_initiated_session_sync() for the synchronous, blocking version of this method.
             * @param arg_session_type Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_start_client_initiated_session(
                arg_session_type: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_oma_call_start_client_initiated_session().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_oma_call_start_client_initiated_session().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_start_client_initiated_session_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.StartClientInitiatedSession">StartClientInitiatedSession()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_oma_call_start_client_initiated_session() for the asynchronous version of this method.
             * @param arg_session_type Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_start_client_initiated_session_sync(
                arg_session_type: number,
                cancellable?: Gio.Cancellable | null,
            ): boolean;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.AcceptNetworkInitiatedSession">AcceptNetworkInitiatedSession()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_accept_network_initiated_session(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.CancelSession">CancelSession()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_cancel_session(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.Setup">Setup()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_setup(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.StartClientInitiatedSession">StartClientInitiatedSession()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_start_client_initiated_session(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Emits the <link linkend="gdbus-signal-org-freedesktop-ModemManager1-Modem-Oma.SessionStateChanged">"SessionStateChanged"</link> D-Bus signal.
             * @param arg_old_session_state Argument to pass with the signal.
             * @param arg_new_session_state Argument to pass with the signal.
             * @param arg_session_state_failed_reason Argument to pass with the signal.
             */
            emit_session_state_changed(
                arg_old_session_state: number,
                arg_new_session_state: number,
                arg_session_state_failed_reason: number,
            ): void;
            vfunc_handle_accept_network_initiated_session(
                invocation: Gio.DBusMethodInvocation,
                arg_session_id: number,
                arg_accept: boolean,
            ): boolean;
            vfunc_handle_cancel_session(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_setup(invocation: Gio.DBusMethodInvocation, arg_features: number): boolean;
            vfunc_handle_start_client_initiated_session(
                invocation: Gio.DBusMethodInvocation,
                arg_session_type: number,
            ): boolean;
            vfunc_session_state_changed(
                arg_old_session_state: number,
                arg_new_session_state: number,
                arg_session_state_failed_reason: number,
            ): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace GdbusModemProxy {
            // Constructor properties interface

            interface ConstructorProps
                extends Gio.DBusProxy.ConstructorProps,
                    Gio.AsyncInitable.ConstructorProps,
                    Gio.DBusInterface.ConstructorProps,
                    Gio.Initable.ConstructorProps,
                    GdbusModem.ConstructorProps {}
        }

        /**
         * The #MmGdbusModemProxy structure contains only private data and should only be accessed using the provided API.
         */
        class GdbusModemProxy
            extends Gio.DBusProxy
            implements Gio.AsyncInitable<GdbusModemProxy>, Gio.DBusInterface, Gio.Initable, GdbusModem
        {
            static $gtype: GObject.GType<GdbusModemProxy>;

            // Constructors

            constructor(properties?: Partial<GdbusModemProxy.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static new_finish(res: Gio.AsyncResult): GdbusModemProxy;
            // Conflicted with Gio.AsyncInitable.new_finish

            static new_finish(...args: never[]): any;

            static new_for_bus_finish(res: Gio.AsyncResult): GdbusModemProxy;

            static new_for_bus_sync(
                bus_type: Gio.BusType,
                flags: Gio.DBusProxyFlags,
                name: string,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
            ): GdbusModemProxy;
            // Conflicted with Gio.DBusProxy.new_for_bus_sync

            static new_for_bus_sync(...args: never[]): any;

            static new_sync(
                connection: Gio.DBusConnection,
                flags: Gio.DBusProxyFlags,
                name: string | null,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
            ): GdbusModemProxy;
            // Conflicted with Gio.DBusProxy.new_sync

            static new_sync(...args: never[]): any;

            // Static methods

            /**
             * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem.top_of_page">org.freedesktop.ModemManager1.Modem</link>. See g_dbus_proxy_new() for more details.
             *
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_proxy_new_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_proxy_new_sync() for the synchronous, blocking version of this constructor.
             * @param connection A #GDBusConnection.
             * @param flags Flags from the #GDBusProxyFlags enumeration.
             * @param name A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
             * @param object_path An object path.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied.
             */
            static ['new'](
                connection: Gio.DBusConnection,
                flags: Gio.DBusProxyFlags,
                name: string | null,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<GdbusModemProxy> | null,
            ): void;
            // Conflicted with Gio.DBusProxy.new
            static ['new'](...args: never[]): any;
            /**
             * Like mm_gdbus_modem_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
             *
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_proxy_new_for_bus_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
             * @param bus_type A #GBusType.
             * @param flags Flags from the #GDBusProxyFlags enumeration.
             * @param name A bus name (well-known or unique).
             * @param object_path An object path.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied.
             */
            static new_for_bus(
                bus_type: Gio.BusType,
                flags: Gio.DBusProxyFlags,
                name: string,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<GdbusModemProxy> | null,
            ): void;
            // Conflicted with Gio.DBusProxy.new_for_bus
            static new_for_bus(...args: never[]): any;

            // Inherited properties
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.AccessTechnologies">"AccessTechnologies"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get access_technologies(): number;
            set access_technologies(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.AccessTechnologies">"AccessTechnologies"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get accessTechnologies(): number;
            set accessTechnologies(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.Bearers">"Bearers"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get bearers(): string[];
            set bearers(val: string[]);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.CarrierConfiguration">"CarrierConfiguration"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get carrier_configuration(): string;
            set carrier_configuration(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.CarrierConfiguration">"CarrierConfiguration"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get carrierConfiguration(): string;
            set carrierConfiguration(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.CarrierConfigurationRevision">"CarrierConfigurationRevision"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get carrier_configuration_revision(): string;
            set carrier_configuration_revision(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.CarrierConfigurationRevision">"CarrierConfigurationRevision"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get carrierConfigurationRevision(): string;
            set carrierConfigurationRevision(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.CurrentBands">"CurrentBands"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get current_bands(): GLib.Variant;
            set current_bands(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.CurrentBands">"CurrentBands"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get currentBands(): GLib.Variant;
            set currentBands(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.CurrentCapabilities">"CurrentCapabilities"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get current_capabilities(): number;
            set current_capabilities(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.CurrentCapabilities">"CurrentCapabilities"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get currentCapabilities(): number;
            set currentCapabilities(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.CurrentModes">"CurrentModes"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get current_modes(): GLib.Variant;
            set current_modes(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.CurrentModes">"CurrentModes"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get currentModes(): GLib.Variant;
            set currentModes(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.Device">"Device"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get device(): string;
            set device(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.DeviceIdentifier">"DeviceIdentifier"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get device_identifier(): string;
            set device_identifier(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.DeviceIdentifier">"DeviceIdentifier"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get deviceIdentifier(): string;
            set deviceIdentifier(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.Drivers">"Drivers"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get drivers(): string[];
            set drivers(val: string[]);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.EquipmentIdentifier">"EquipmentIdentifier"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get equipment_identifier(): string;
            set equipment_identifier(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.EquipmentIdentifier">"EquipmentIdentifier"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get equipmentIdentifier(): string;
            set equipmentIdentifier(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.HardwareRevision">"HardwareRevision"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get hardware_revision(): string;
            set hardware_revision(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.HardwareRevision">"HardwareRevision"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get hardwareRevision(): string;
            set hardwareRevision(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.Manufacturer">"Manufacturer"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get manufacturer(): string;
            set manufacturer(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.MaxActiveBearers">"MaxActiveBearers"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get max_active_bearers(): number;
            set max_active_bearers(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.MaxActiveBearers">"MaxActiveBearers"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get maxActiveBearers(): number;
            set maxActiveBearers(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.MaxActiveMultiplexedBearers">"MaxActiveMultiplexedBearers"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get max_active_multiplexed_bearers(): number;
            set max_active_multiplexed_bearers(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.MaxActiveMultiplexedBearers">"MaxActiveMultiplexedBearers"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get maxActiveMultiplexedBearers(): number;
            set maxActiveMultiplexedBearers(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.MaxBearers">"MaxBearers"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get max_bearers(): number;
            set max_bearers(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.MaxBearers">"MaxBearers"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get maxBearers(): number;
            set maxBearers(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.Model">"Model"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get model(): string;
            set model(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.OwnNumbers">"OwnNumbers"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get own_numbers(): string[];
            set own_numbers(val: string[]);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.OwnNumbers">"OwnNumbers"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get ownNumbers(): string[];
            set ownNumbers(val: string[]);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.Physdev">"Physdev"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get physdev(): string;
            set physdev(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.Plugin">"Plugin"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get plugin(): string;
            set plugin(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.Ports">"Ports"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get ports(): GLib.Variant;
            set ports(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.PowerState">"PowerState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get power_state(): number;
            set power_state(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.PowerState">"PowerState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get powerState(): number;
            set powerState(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.PrimaryPort">"PrimaryPort"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get primary_port(): string;
            set primary_port(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.PrimaryPort">"PrimaryPort"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get primaryPort(): string;
            set primaryPort(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.PrimarySimSlot">"PrimarySimSlot"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get primary_sim_slot(): number;
            set primary_sim_slot(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.PrimarySimSlot">"PrimarySimSlot"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get primarySimSlot(): number;
            set primarySimSlot(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.Revision">"Revision"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get revision(): string;
            set revision(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.SignalQuality">"SignalQuality"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get signal_quality(): GLib.Variant;
            set signal_quality(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.SignalQuality">"SignalQuality"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get signalQuality(): GLib.Variant;
            set signalQuality(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.Sim">"Sim"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get sim(): string;
            set sim(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.SimSlots">"SimSlots"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get sim_slots(): string[];
            set sim_slots(val: string[]);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.SimSlots">"SimSlots"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get simSlots(): string[];
            set simSlots(val: string[]);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.State">"State"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get state(): number;
            set state(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.StateFailedReason">"StateFailedReason"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get state_failed_reason(): number;
            set state_failed_reason(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.StateFailedReason">"StateFailedReason"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get stateFailedReason(): number;
            set stateFailedReason(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.SupportedBands">"SupportedBands"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get supported_bands(): GLib.Variant;
            set supported_bands(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.SupportedBands">"SupportedBands"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get supportedBands(): GLib.Variant;
            set supportedBands(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.SupportedCapabilities">"SupportedCapabilities"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get supported_capabilities(): GLib.Variant;
            set supported_capabilities(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.SupportedCapabilities">"SupportedCapabilities"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get supportedCapabilities(): GLib.Variant;
            set supportedCapabilities(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.SupportedIpFamilies">"SupportedIpFamilies"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get supported_ip_families(): number;
            set supported_ip_families(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.SupportedIpFamilies">"SupportedIpFamilies"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get supportedIpFamilies(): number;
            set supportedIpFamilies(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.SupportedModes">"SupportedModes"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get supported_modes(): GLib.Variant;
            set supported_modes(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.SupportedModes">"SupportedModes"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get supportedModes(): GLib.Variant;
            set supportedModes(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.UnlockRequired">"UnlockRequired"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get unlock_required(): number;
            set unlock_required(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.UnlockRequired">"UnlockRequired"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get unlockRequired(): number;
            set unlockRequired(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.UnlockRetries">"UnlockRetries"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get unlock_retries(): GLib.Variant;
            set unlock_retries(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.UnlockRetries">"UnlockRetries"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get unlockRetries(): GLib.Variant;
            set unlockRetries(val: GLib.Variant);

            // Inherited methods
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            init_async(io_priority: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             * @returns %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present.
             */
            init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Finishes the async construction for the various g_async_initable_new
             * calls, returning the created object or %NULL on error.
             * @param res the #GAsyncResult from the callback
             * @returns a newly created #GObject,      or %NULL on error. Free with g_object_unref().
             */
            new_finish(res: Gio.AsyncResult): GdbusModemProxy;
            // Conflicted with Gio.DBusProxy.new_finish
            new_finish(...args: never[]): any;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            vfunc_init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             */
            vfunc_init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             * @returns A #GDBusObject or %NULL. The returned reference should be freed with g_object_unref().
             */
            get_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             * @returns A #GDBusInterfaceInfo. Do not free.
             */
            get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            set_object(object?: Gio.DBusObject | null): void;
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             */
            vfunc_dup_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             */
            vfunc_get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            vfunc_set_object(object?: Gio.DBusObject | null): void;
            /**
             * Initializes the object implementing the interface.
             *
             * This method is intended for language bindings. If writing in C,
             * g_initable_new() should typically be used instead.
             *
             * The object must be initialized before any real use after initial
             * construction, either with this function or g_async_initable_init_async().
             *
             * Implementations may also support cancellation. If `cancellable` is not %NULL,
             * then initialization can be cancelled by triggering the cancellable object
             * from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
             * the object doesn't support cancellable initialization the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * If the object is not initialized, or initialization returns with an
             * error, then all operations on the object except g_object_ref() and
             * g_object_unref() are considered to be invalid, and have undefined
             * behaviour. See the [description][iface`Gio`.Initable#description] for more details.
             *
             * Callers should not assume that a class which implements #GInitable can be
             * initialized multiple times, unless the class explicitly documents itself as
             * supporting this. Generally, a class’ implementation of init() can assume
             * (and assert) that it will only be called once. Previously, this documentation
             * recommended all #GInitable implementations should be idempotent; that
             * recommendation was relaxed in GLib 2.54.
             *
             * If a class explicitly supports being initialized multiple times, it is
             * recommended that the method is idempotent: multiple calls with the same
             * arguments should return the same results. Only the first call initializes
             * the object; further calls return the result of the first call.
             *
             * One reason why a class might need to support idempotent initialization is if
             * it is designed to be used via the singleton pattern, with a
             * #GObjectClass.constructor that sometimes returns an existing instance.
             * In this pattern, a caller would expect to be able to call g_initable_init()
             * on the result of g_object_new(), regardless of whether it is in fact a new
             * instance.
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @returns %TRUE if successful. If an error has occurred, this function will     return %FALSE and set @error appropriately if present.
             */
            init(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Initializes the object implementing the interface.
             *
             * This method is intended for language bindings. If writing in C,
             * g_initable_new() should typically be used instead.
             *
             * The object must be initialized before any real use after initial
             * construction, either with this function or g_async_initable_init_async().
             *
             * Implementations may also support cancellation. If `cancellable` is not %NULL,
             * then initialization can be cancelled by triggering the cancellable object
             * from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
             * the object doesn't support cancellable initialization the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * If the object is not initialized, or initialization returns with an
             * error, then all operations on the object except g_object_ref() and
             * g_object_unref() are considered to be invalid, and have undefined
             * behaviour. See the [description][iface`Gio`.Initable#description] for more details.
             *
             * Callers should not assume that a class which implements #GInitable can be
             * initialized multiple times, unless the class explicitly documents itself as
             * supporting this. Generally, a class’ implementation of init() can assume
             * (and assert) that it will only be called once. Previously, this documentation
             * recommended all #GInitable implementations should be idempotent; that
             * recommendation was relaxed in GLib 2.54.
             *
             * If a class explicitly supports being initialized multiple times, it is
             * recommended that the method is idempotent: multiple calls with the same
             * arguments should return the same results. Only the first call initializes
             * the object; further calls return the result of the first call.
             *
             * One reason why a class might need to support idempotent initialization is if
             * it is designed to be used via the singleton pattern, with a
             * #GObjectClass.constructor that sometimes returns an existing instance.
             * In this pattern, a caller would expect to be able to call g_initable_init()
             * on the result of g_object_new(), regardless of whether it is in fact a new
             * instance.
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            vfunc_init(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.Command">Command()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_command_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_command_sync() for the synchronous, blocking version of this method.
             * @param arg_cmd Argument to pass with the method invocation.
             * @param arg_timeout Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_command(arg_cmd: string, arg_timeout: number, cancellable?: Gio.Cancellable | null): Promise<string>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.Command">Command()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_command_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_command_sync() for the synchronous, blocking version of this method.
             * @param arg_cmd Argument to pass with the method invocation.
             * @param arg_timeout Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_command(
                arg_cmd: string,
                arg_timeout: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.Command">Command()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_command_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_command_sync() for the synchronous, blocking version of this method.
             * @param arg_cmd Argument to pass with the method invocation.
             * @param arg_timeout Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_command(
                arg_cmd: string,
                arg_timeout: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<string> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_call_command().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_call_command().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_command_finish(res: Gio.AsyncResult): [boolean, string];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.Command">Command()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_call_command() for the asynchronous version of this method.
             * @param arg_cmd Argument to pass with the method invocation.
             * @param arg_timeout Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_command_sync(
                arg_cmd: string,
                arg_timeout: number,
                cancellable?: Gio.Cancellable | null,
            ): [boolean, string];
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.CreateBearer">CreateBearer()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_create_bearer_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_create_bearer_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_create_bearer(arg_properties: GLib.Variant, cancellable?: Gio.Cancellable | null): Promise<string>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.CreateBearer">CreateBearer()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_create_bearer_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_create_bearer_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_create_bearer(
                arg_properties: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.CreateBearer">CreateBearer()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_create_bearer_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_create_bearer_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_create_bearer(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<string> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_call_create_bearer().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_call_create_bearer().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_create_bearer_finish(res: Gio.AsyncResult): [boolean, string];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.CreateBearer">CreateBearer()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_call_create_bearer() for the asynchronous version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_create_bearer_sync(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
            ): [boolean, string];
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.DeleteBearer">DeleteBearer()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_delete_bearer_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_delete_bearer_sync() for the synchronous, blocking version of this method.
             * @param arg_bearer Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_delete_bearer(arg_bearer: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.DeleteBearer">DeleteBearer()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_delete_bearer_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_delete_bearer_sync() for the synchronous, blocking version of this method.
             * @param arg_bearer Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_delete_bearer(
                arg_bearer: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.DeleteBearer">DeleteBearer()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_delete_bearer_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_delete_bearer_sync() for the synchronous, blocking version of this method.
             * @param arg_bearer Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_delete_bearer(
                arg_bearer: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_call_delete_bearer().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_call_delete_bearer().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_delete_bearer_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.DeleteBearer">DeleteBearer()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_call_delete_bearer() for the asynchronous version of this method.
             * @param arg_bearer Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_delete_bearer_sync(arg_bearer: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.Enable">Enable()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_enable_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_enable_sync() for the synchronous, blocking version of this method.
             * @param arg_enable Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_enable(arg_enable: boolean, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.Enable">Enable()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_enable_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_enable_sync() for the synchronous, blocking version of this method.
             * @param arg_enable Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_enable(
                arg_enable: boolean,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.Enable">Enable()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_enable_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_enable_sync() for the synchronous, blocking version of this method.
             * @param arg_enable Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_enable(
                arg_enable: boolean,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_call_enable().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_call_enable().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_enable_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.Enable">Enable()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_call_enable() for the asynchronous version of this method.
             * @param arg_enable Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_enable_sync(arg_enable: boolean, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.FactoryReset">FactoryReset()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_factory_reset_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_factory_reset_sync() for the synchronous, blocking version of this method.
             * @param arg_code Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_factory_reset(arg_code: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.FactoryReset">FactoryReset()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_factory_reset_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_factory_reset_sync() for the synchronous, blocking version of this method.
             * @param arg_code Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_factory_reset(
                arg_code: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.FactoryReset">FactoryReset()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_factory_reset_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_factory_reset_sync() for the synchronous, blocking version of this method.
             * @param arg_code Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_factory_reset(
                arg_code: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_call_factory_reset().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_call_factory_reset().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_factory_reset_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.FactoryReset">FactoryReset()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_call_factory_reset() for the asynchronous version of this method.
             * @param arg_code Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_factory_reset_sync(arg_code: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.GetCellInfo">GetCellInfo()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_get_cell_info_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_get_cell_info_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_get_cell_info(cancellable?: Gio.Cancellable | null): Promise<GLib.Variant | null>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.GetCellInfo">GetCellInfo()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_get_cell_info_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_get_cell_info_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_get_cell_info(
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.GetCellInfo">GetCellInfo()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_get_cell_info_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_get_cell_info_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_get_cell_info(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<GLib.Variant | null> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_call_get_cell_info().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_call_get_cell_info().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_get_cell_info_finish(res: Gio.AsyncResult): [boolean, GLib.Variant | null];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.GetCellInfo">GetCellInfo()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_call_get_cell_info() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_get_cell_info_sync(cancellable?: Gio.Cancellable | null): [boolean, GLib.Variant | null];
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.ListBearers">ListBearers()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_list_bearers_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_list_bearers_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_list_bearers(cancellable?: Gio.Cancellable | null): Promise<string[] | null>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.ListBearers">ListBearers()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_list_bearers_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_list_bearers_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_list_bearers(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.ListBearers">ListBearers()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_list_bearers_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_list_bearers_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_list_bearers(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<string[] | null> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_call_list_bearers().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_call_list_bearers().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_list_bearers_finish(res: Gio.AsyncResult): [boolean, string[] | null];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.ListBearers">ListBearers()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_call_list_bearers() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_list_bearers_sync(cancellable?: Gio.Cancellable | null): [boolean, string[] | null];
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.Reset">Reset()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_reset_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_reset_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_reset(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.Reset">Reset()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_reset_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_reset_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_reset(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.Reset">Reset()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_reset_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_reset_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_reset(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_call_reset().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_call_reset().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_reset_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.Reset">Reset()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_call_reset() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_reset_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetCurrentBands">SetCurrentBands()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_set_current_bands_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_set_current_bands_sync() for the synchronous, blocking version of this method.
             * @param arg_bands Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set_current_bands(arg_bands: GLib.Variant, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetCurrentBands">SetCurrentBands()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_set_current_bands_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_set_current_bands_sync() for the synchronous, blocking version of this method.
             * @param arg_bands Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_current_bands(
                arg_bands: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetCurrentBands">SetCurrentBands()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_set_current_bands_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_set_current_bands_sync() for the synchronous, blocking version of this method.
             * @param arg_bands Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_current_bands(
                arg_bands: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_call_set_current_bands().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_call_set_current_bands().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_current_bands_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetCurrentBands">SetCurrentBands()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_call_set_current_bands() for the asynchronous version of this method.
             * @param arg_bands Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_current_bands_sync(arg_bands: GLib.Variant, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetCurrentCapabilities">SetCurrentCapabilities()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_set_current_capabilities_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_set_current_capabilities_sync() for the synchronous, blocking version of this method.
             * @param arg_capabilities Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set_current_capabilities(
                arg_capabilities: number,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetCurrentCapabilities">SetCurrentCapabilities()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_set_current_capabilities_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_set_current_capabilities_sync() for the synchronous, blocking version of this method.
             * @param arg_capabilities Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_current_capabilities(
                arg_capabilities: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetCurrentCapabilities">SetCurrentCapabilities()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_set_current_capabilities_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_set_current_capabilities_sync() for the synchronous, blocking version of this method.
             * @param arg_capabilities Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_current_capabilities(
                arg_capabilities: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_call_set_current_capabilities().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_call_set_current_capabilities().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_current_capabilities_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetCurrentCapabilities">SetCurrentCapabilities()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_call_set_current_capabilities() for the asynchronous version of this method.
             * @param arg_capabilities Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_current_capabilities_sync(arg_capabilities: number, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetCurrentModes">SetCurrentModes()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_set_current_modes_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_set_current_modes_sync() for the synchronous, blocking version of this method.
             * @param arg_modes Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set_current_modes(arg_modes: GLib.Variant, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetCurrentModes">SetCurrentModes()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_set_current_modes_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_set_current_modes_sync() for the synchronous, blocking version of this method.
             * @param arg_modes Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_current_modes(
                arg_modes: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetCurrentModes">SetCurrentModes()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_set_current_modes_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_set_current_modes_sync() for the synchronous, blocking version of this method.
             * @param arg_modes Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_current_modes(
                arg_modes: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_call_set_current_modes().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_call_set_current_modes().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_current_modes_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetCurrentModes">SetCurrentModes()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_call_set_current_modes() for the asynchronous version of this method.
             * @param arg_modes Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_current_modes_sync(arg_modes: GLib.Variant, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetPowerState">SetPowerState()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_set_power_state_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_set_power_state_sync() for the synchronous, blocking version of this method.
             * @param arg_state Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set_power_state(arg_state: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetPowerState">SetPowerState()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_set_power_state_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_set_power_state_sync() for the synchronous, blocking version of this method.
             * @param arg_state Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_power_state(
                arg_state: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetPowerState">SetPowerState()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_set_power_state_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_set_power_state_sync() for the synchronous, blocking version of this method.
             * @param arg_state Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_power_state(
                arg_state: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_call_set_power_state().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_call_set_power_state().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_power_state_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetPowerState">SetPowerState()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_call_set_power_state() for the asynchronous version of this method.
             * @param arg_state Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_power_state_sync(arg_state: number, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetPrimarySimSlot">SetPrimarySimSlot()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_set_primary_sim_slot_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_set_primary_sim_slot_sync() for the synchronous, blocking version of this method.
             * @param arg_sim_slot Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set_primary_sim_slot(arg_sim_slot: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetPrimarySimSlot">SetPrimarySimSlot()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_set_primary_sim_slot_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_set_primary_sim_slot_sync() for the synchronous, blocking version of this method.
             * @param arg_sim_slot Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_primary_sim_slot(
                arg_sim_slot: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetPrimarySimSlot">SetPrimarySimSlot()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_set_primary_sim_slot_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_set_primary_sim_slot_sync() for the synchronous, blocking version of this method.
             * @param arg_sim_slot Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_primary_sim_slot(
                arg_sim_slot: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_call_set_primary_sim_slot().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_call_set_primary_sim_slot().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_primary_sim_slot_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetPrimarySimSlot">SetPrimarySimSlot()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_call_set_primary_sim_slot() for the asynchronous version of this method.
             * @param arg_sim_slot Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_primary_sim_slot_sync(arg_sim_slot: number, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.Command">Command()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param response Parameter to return.
             */
            complete_command(invocation: Gio.DBusMethodInvocation, response: string): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.CreateBearer">CreateBearer()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param path Parameter to return.
             */
            complete_create_bearer(invocation: Gio.DBusMethodInvocation, path: string): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.DeleteBearer">DeleteBearer()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_delete_bearer(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.Enable">Enable()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_enable(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.FactoryReset">FactoryReset()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_factory_reset(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.GetCellInfo">GetCellInfo()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param cell_info Parameter to return.
             */
            complete_get_cell_info(invocation: Gio.DBusMethodInvocation, cell_info: GLib.Variant): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.ListBearers">ListBearers()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param bearers Parameter to return.
             */
            complete_list_bearers(invocation: Gio.DBusMethodInvocation, bearers: string): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.Reset">Reset()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_reset(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetCurrentBands">SetCurrentBands()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_set_current_bands(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetCurrentCapabilities">SetCurrentCapabilities()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_set_current_capabilities(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetCurrentModes">SetCurrentModes()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_set_current_modes(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetPowerState">SetPowerState()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_set_power_state(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetPrimarySimSlot">SetPrimarySimSlot()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_set_primary_sim_slot(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Emits the <link linkend="gdbus-signal-org-freedesktop-ModemManager1-Modem.StateChanged">"StateChanged"</link> D-Bus signal.
             * @param arg_old Argument to pass with the signal.
             * @param arg_new Argument to pass with the signal.
             * @param arg_reason Argument to pass with the signal.
             */
            emit_state_changed(arg_old: number, arg_new: number, arg_reason: number): void;
            vfunc_handle_command(invocation: Gio.DBusMethodInvocation, arg_cmd: string, arg_timeout: number): boolean;
            vfunc_handle_create_bearer(invocation: Gio.DBusMethodInvocation, arg_properties: GLib.Variant): boolean;
            vfunc_handle_delete_bearer(invocation: Gio.DBusMethodInvocation, arg_bearer: string): boolean;
            vfunc_handle_enable(invocation: Gio.DBusMethodInvocation, arg_enable: boolean): boolean;
            vfunc_handle_factory_reset(invocation: Gio.DBusMethodInvocation, arg_code: string): boolean;
            vfunc_handle_get_cell_info(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_list_bearers(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_reset(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_set_current_bands(invocation: Gio.DBusMethodInvocation, arg_bands: GLib.Variant): boolean;
            vfunc_handle_set_current_capabilities(
                invocation: Gio.DBusMethodInvocation,
                arg_capabilities: number,
            ): boolean;
            vfunc_handle_set_current_modes(invocation: Gio.DBusMethodInvocation, arg_modes: GLib.Variant): boolean;
            vfunc_handle_set_power_state(invocation: Gio.DBusMethodInvocation, arg_state: number): boolean;
            vfunc_handle_set_primary_sim_slot(invocation: Gio.DBusMethodInvocation, arg_sim_slot: number): boolean;
            vfunc_state_changed(arg_old: number, arg_new: number, arg_reason: number): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace GdbusModemSarProxy {
            // Constructor properties interface

            interface ConstructorProps
                extends Gio.DBusProxy.ConstructorProps,
                    Gio.AsyncInitable.ConstructorProps,
                    Gio.DBusInterface.ConstructorProps,
                    Gio.Initable.ConstructorProps,
                    GdbusModemSar.ConstructorProps {}
        }

        /**
         * The #MmGdbusModemSarProxy structure contains only private data and should only be accessed using the provided API.
         */
        class GdbusModemSarProxy
            extends Gio.DBusProxy
            implements Gio.AsyncInitable<GdbusModemSarProxy>, Gio.DBusInterface, Gio.Initable, GdbusModemSar
        {
            static $gtype: GObject.GType<GdbusModemSarProxy>;

            // Constructors

            constructor(properties?: Partial<GdbusModemSarProxy.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static new_finish(res: Gio.AsyncResult): GdbusModemSarProxy;
            // Conflicted with Gio.AsyncInitable.new_finish

            static new_finish(...args: never[]): any;

            static new_for_bus_finish(res: Gio.AsyncResult): GdbusModemSarProxy;

            static new_for_bus_sync(
                bus_type: Gio.BusType,
                flags: Gio.DBusProxyFlags,
                name: string,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
            ): GdbusModemSarProxy;
            // Conflicted with Gio.DBusProxy.new_for_bus_sync

            static new_for_bus_sync(...args: never[]): any;

            static new_sync(
                connection: Gio.DBusConnection,
                flags: Gio.DBusProxyFlags,
                name: string | null,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
            ): GdbusModemSarProxy;
            // Conflicted with Gio.DBusProxy.new_sync

            static new_sync(...args: never[]): any;

            // Static methods

            /**
             * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Sar.top_of_page">org.freedesktop.ModemManager1.Modem.Sar</link>. See g_dbus_proxy_new() for more details.
             *
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_sar_proxy_new_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_sar_proxy_new_sync() for the synchronous, blocking version of this constructor.
             * @param connection A #GDBusConnection.
             * @param flags Flags from the #GDBusProxyFlags enumeration.
             * @param name A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
             * @param object_path An object path.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied.
             */
            static ['new'](
                connection: Gio.DBusConnection,
                flags: Gio.DBusProxyFlags,
                name: string | null,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<GdbusModemSarProxy> | null,
            ): void;
            // Conflicted with Gio.DBusProxy.new
            static ['new'](...args: never[]): any;
            /**
             * Like mm_gdbus_modem_sar_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
             *
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_sar_proxy_new_for_bus_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_sar_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
             * @param bus_type A #GBusType.
             * @param flags Flags from the #GDBusProxyFlags enumeration.
             * @param name A bus name (well-known or unique).
             * @param object_path An object path.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied.
             */
            static new_for_bus(
                bus_type: Gio.BusType,
                flags: Gio.DBusProxyFlags,
                name: string,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<GdbusModemSarProxy> | null,
            ): void;
            // Conflicted with Gio.DBusProxy.new_for_bus
            static new_for_bus(...args: never[]): any;

            // Inherited properties
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Sar.PowerLevel">"PowerLevel"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get power_level(): number;
            set power_level(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Sar.PowerLevel">"PowerLevel"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get powerLevel(): number;
            set powerLevel(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Sar.State">"State"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get state(): boolean;
            set state(val: boolean);

            // Inherited methods
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            init_async(io_priority: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             * @returns %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present.
             */
            init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Finishes the async construction for the various g_async_initable_new
             * calls, returning the created object or %NULL on error.
             * @param res the #GAsyncResult from the callback
             * @returns a newly created #GObject,      or %NULL on error. Free with g_object_unref().
             */
            new_finish(res: Gio.AsyncResult): GdbusModemSarProxy;
            // Conflicted with Gio.DBusProxy.new_finish
            new_finish(...args: never[]): any;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            vfunc_init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             */
            vfunc_init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             * @returns A #GDBusObject or %NULL. The returned reference should be freed with g_object_unref().
             */
            get_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             * @returns A #GDBusInterfaceInfo. Do not free.
             */
            get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            set_object(object?: Gio.DBusObject | null): void;
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             */
            vfunc_dup_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             */
            vfunc_get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            vfunc_set_object(object?: Gio.DBusObject | null): void;
            /**
             * Initializes the object implementing the interface.
             *
             * This method is intended for language bindings. If writing in C,
             * g_initable_new() should typically be used instead.
             *
             * The object must be initialized before any real use after initial
             * construction, either with this function or g_async_initable_init_async().
             *
             * Implementations may also support cancellation. If `cancellable` is not %NULL,
             * then initialization can be cancelled by triggering the cancellable object
             * from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
             * the object doesn't support cancellable initialization the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * If the object is not initialized, or initialization returns with an
             * error, then all operations on the object except g_object_ref() and
             * g_object_unref() are considered to be invalid, and have undefined
             * behaviour. See the [description][iface`Gio`.Initable#description] for more details.
             *
             * Callers should not assume that a class which implements #GInitable can be
             * initialized multiple times, unless the class explicitly documents itself as
             * supporting this. Generally, a class’ implementation of init() can assume
             * (and assert) that it will only be called once. Previously, this documentation
             * recommended all #GInitable implementations should be idempotent; that
             * recommendation was relaxed in GLib 2.54.
             *
             * If a class explicitly supports being initialized multiple times, it is
             * recommended that the method is idempotent: multiple calls with the same
             * arguments should return the same results. Only the first call initializes
             * the object; further calls return the result of the first call.
             *
             * One reason why a class might need to support idempotent initialization is if
             * it is designed to be used via the singleton pattern, with a
             * #GObjectClass.constructor that sometimes returns an existing instance.
             * In this pattern, a caller would expect to be able to call g_initable_init()
             * on the result of g_object_new(), regardless of whether it is in fact a new
             * instance.
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @returns %TRUE if successful. If an error has occurred, this function will     return %FALSE and set @error appropriately if present.
             */
            init(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Initializes the object implementing the interface.
             *
             * This method is intended for language bindings. If writing in C,
             * g_initable_new() should typically be used instead.
             *
             * The object must be initialized before any real use after initial
             * construction, either with this function or g_async_initable_init_async().
             *
             * Implementations may also support cancellation. If `cancellable` is not %NULL,
             * then initialization can be cancelled by triggering the cancellable object
             * from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
             * the object doesn't support cancellable initialization the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * If the object is not initialized, or initialization returns with an
             * error, then all operations on the object except g_object_ref() and
             * g_object_unref() are considered to be invalid, and have undefined
             * behaviour. See the [description][iface`Gio`.Initable#description] for more details.
             *
             * Callers should not assume that a class which implements #GInitable can be
             * initialized multiple times, unless the class explicitly documents itself as
             * supporting this. Generally, a class’ implementation of init() can assume
             * (and assert) that it will only be called once. Previously, this documentation
             * recommended all #GInitable implementations should be idempotent; that
             * recommendation was relaxed in GLib 2.54.
             *
             * If a class explicitly supports being initialized multiple times, it is
             * recommended that the method is idempotent: multiple calls with the same
             * arguments should return the same results. Only the first call initializes
             * the object; further calls return the result of the first call.
             *
             * One reason why a class might need to support idempotent initialization is if
             * it is designed to be used via the singleton pattern, with a
             * #GObjectClass.constructor that sometimes returns an existing instance.
             * In this pattern, a caller would expect to be able to call g_initable_init()
             * on the result of g_object_new(), regardless of whether it is in fact a new
             * instance.
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            vfunc_init(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Sar.Enable">Enable()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_sar_call_enable_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_sar_call_enable_sync() for the synchronous, blocking version of this method.
             * @param arg_enable Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_enable(arg_enable: boolean, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Sar.Enable">Enable()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_sar_call_enable_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_sar_call_enable_sync() for the synchronous, blocking version of this method.
             * @param arg_enable Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_enable(
                arg_enable: boolean,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Sar.Enable">Enable()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_sar_call_enable_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_sar_call_enable_sync() for the synchronous, blocking version of this method.
             * @param arg_enable Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_enable(
                arg_enable: boolean,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_sar_call_enable().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_sar_call_enable().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_enable_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Sar.Enable">Enable()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_sar_call_enable() for the asynchronous version of this method.
             * @param arg_enable Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_enable_sync(arg_enable: boolean, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Sar.SetPowerLevel">SetPowerLevel()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_sar_call_set_power_level_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_sar_call_set_power_level_sync() for the synchronous, blocking version of this method.
             * @param arg_level Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set_power_level(arg_level: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Sar.SetPowerLevel">SetPowerLevel()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_sar_call_set_power_level_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_sar_call_set_power_level_sync() for the synchronous, blocking version of this method.
             * @param arg_level Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_power_level(
                arg_level: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Sar.SetPowerLevel">SetPowerLevel()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_sar_call_set_power_level_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_sar_call_set_power_level_sync() for the synchronous, blocking version of this method.
             * @param arg_level Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_power_level(
                arg_level: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_sar_call_set_power_level().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_sar_call_set_power_level().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_power_level_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Sar.SetPowerLevel">SetPowerLevel()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_sar_call_set_power_level() for the asynchronous version of this method.
             * @param arg_level Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_power_level_sync(arg_level: number, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Sar.Enable">Enable()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_enable(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Sar.SetPowerLevel">SetPowerLevel()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_set_power_level(invocation: Gio.DBusMethodInvocation): void;
            vfunc_handle_enable(invocation: Gio.DBusMethodInvocation, arg_enable: boolean): boolean;
            vfunc_handle_set_power_level(invocation: Gio.DBusMethodInvocation, arg_level: number): boolean;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace GdbusModemSarSkeleton {
            // Constructor properties interface

            interface ConstructorProps
                extends Gio.DBusInterfaceSkeleton.ConstructorProps,
                    Gio.DBusInterface.ConstructorProps,
                    GdbusModemSar.ConstructorProps {}
        }

        /**
         * The #MmGdbusModemSarSkeleton structure contains only private data and should only be accessed using the provided API.
         */
        class GdbusModemSarSkeleton extends Gio.DBusInterfaceSkeleton implements Gio.DBusInterface, GdbusModemSar {
            static $gtype: GObject.GType<GdbusModemSarSkeleton>;

            // Constructors

            constructor(properties?: Partial<GdbusModemSarSkeleton.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static ['new'](): GdbusModemSarSkeleton;

            // Inherited properties
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Sar.PowerLevel">"PowerLevel"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get power_level(): number;
            set power_level(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Sar.PowerLevel">"PowerLevel"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get powerLevel(): number;
            set powerLevel(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Sar.State">"State"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get state(): boolean;
            set state(val: boolean);

            // Inherited methods
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             * @returns A #GDBusObject or %NULL. The returned reference should be freed with g_object_unref().
             */
            get_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             * @returns A #GDBusInterfaceInfo. Do not free.
             */
            get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            set_object(object?: Gio.DBusObject | null): void;
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             */
            vfunc_dup_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             */
            vfunc_get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            vfunc_set_object(object?: Gio.DBusObject | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Sar.Enable">Enable()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_sar_call_enable_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_sar_call_enable_sync() for the synchronous, blocking version of this method.
             * @param arg_enable Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_enable(arg_enable: boolean, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Sar.Enable">Enable()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_sar_call_enable_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_sar_call_enable_sync() for the synchronous, blocking version of this method.
             * @param arg_enable Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_enable(
                arg_enable: boolean,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Sar.Enable">Enable()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_sar_call_enable_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_sar_call_enable_sync() for the synchronous, blocking version of this method.
             * @param arg_enable Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_enable(
                arg_enable: boolean,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_sar_call_enable().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_sar_call_enable().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_enable_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Sar.Enable">Enable()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_sar_call_enable() for the asynchronous version of this method.
             * @param arg_enable Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_enable_sync(arg_enable: boolean, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Sar.SetPowerLevel">SetPowerLevel()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_sar_call_set_power_level_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_sar_call_set_power_level_sync() for the synchronous, blocking version of this method.
             * @param arg_level Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set_power_level(arg_level: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Sar.SetPowerLevel">SetPowerLevel()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_sar_call_set_power_level_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_sar_call_set_power_level_sync() for the synchronous, blocking version of this method.
             * @param arg_level Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_power_level(
                arg_level: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Sar.SetPowerLevel">SetPowerLevel()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_sar_call_set_power_level_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_sar_call_set_power_level_sync() for the synchronous, blocking version of this method.
             * @param arg_level Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_power_level(
                arg_level: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_sar_call_set_power_level().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_sar_call_set_power_level().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_power_level_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Sar.SetPowerLevel">SetPowerLevel()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_sar_call_set_power_level() for the asynchronous version of this method.
             * @param arg_level Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_power_level_sync(arg_level: number, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Sar.Enable">Enable()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_enable(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Sar.SetPowerLevel">SetPowerLevel()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_set_power_level(invocation: Gio.DBusMethodInvocation): void;
            vfunc_handle_enable(invocation: Gio.DBusMethodInvocation, arg_enable: boolean): boolean;
            vfunc_handle_set_power_level(invocation: Gio.DBusMethodInvocation, arg_level: number): boolean;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace GdbusModemSignalProxy {
            // Constructor properties interface

            interface ConstructorProps
                extends Gio.DBusProxy.ConstructorProps,
                    Gio.AsyncInitable.ConstructorProps,
                    Gio.DBusInterface.ConstructorProps,
                    Gio.Initable.ConstructorProps,
                    GdbusModemSignal.ConstructorProps {}
        }

        /**
         * The #MmGdbusModemSignalProxy structure contains only private data and should only be accessed using the provided API.
         */
        class GdbusModemSignalProxy
            extends Gio.DBusProxy
            implements Gio.AsyncInitable<GdbusModemSignalProxy>, Gio.DBusInterface, Gio.Initable, GdbusModemSignal
        {
            static $gtype: GObject.GType<GdbusModemSignalProxy>;

            // Constructors

            constructor(properties?: Partial<GdbusModemSignalProxy.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static new_finish(res: Gio.AsyncResult): GdbusModemSignalProxy;
            // Conflicted with Gio.AsyncInitable.new_finish

            static new_finish(...args: never[]): any;

            static new_for_bus_finish(res: Gio.AsyncResult): GdbusModemSignalProxy;

            static new_for_bus_sync(
                bus_type: Gio.BusType,
                flags: Gio.DBusProxyFlags,
                name: string,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
            ): GdbusModemSignalProxy;
            // Conflicted with Gio.DBusProxy.new_for_bus_sync

            static new_for_bus_sync(...args: never[]): any;

            static new_sync(
                connection: Gio.DBusConnection,
                flags: Gio.DBusProxyFlags,
                name: string | null,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
            ): GdbusModemSignalProxy;
            // Conflicted with Gio.DBusProxy.new_sync

            static new_sync(...args: never[]): any;

            // Static methods

            /**
             * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Signal.top_of_page">org.freedesktop.ModemManager1.Modem.Signal</link>. See g_dbus_proxy_new() for more details.
             *
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_signal_proxy_new_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_signal_proxy_new_sync() for the synchronous, blocking version of this constructor.
             * @param connection A #GDBusConnection.
             * @param flags Flags from the #GDBusProxyFlags enumeration.
             * @param name A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
             * @param object_path An object path.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied.
             */
            static ['new'](
                connection: Gio.DBusConnection,
                flags: Gio.DBusProxyFlags,
                name: string | null,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<GdbusModemSignalProxy> | null,
            ): void;
            // Conflicted with Gio.DBusProxy.new
            static ['new'](...args: never[]): any;
            /**
             * Like mm_gdbus_modem_signal_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
             *
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_signal_proxy_new_for_bus_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_signal_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
             * @param bus_type A #GBusType.
             * @param flags Flags from the #GDBusProxyFlags enumeration.
             * @param name A bus name (well-known or unique).
             * @param object_path An object path.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied.
             */
            static new_for_bus(
                bus_type: Gio.BusType,
                flags: Gio.DBusProxyFlags,
                name: string,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<GdbusModemSignalProxy> | null,
            ): void;
            // Conflicted with Gio.DBusProxy.new_for_bus
            static new_for_bus(...args: never[]): any;

            // Inherited properties
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Signal.Cdma">"Cdma"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get cdma(): GLib.Variant;
            set cdma(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Signal.ErrorRateThreshold">"ErrorRateThreshold"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get error_rate_threshold(): boolean;
            set error_rate_threshold(val: boolean);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Signal.ErrorRateThreshold">"ErrorRateThreshold"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get errorRateThreshold(): boolean;
            set errorRateThreshold(val: boolean);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Signal.Evdo">"Evdo"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get evdo(): GLib.Variant;
            set evdo(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Signal.Gsm">"Gsm"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get gsm(): GLib.Variant;
            set gsm(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Signal.Lte">"Lte"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get lte(): GLib.Variant;
            set lte(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Signal.Nr5g">"Nr5g"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get nr5g(): GLib.Variant;
            set nr5g(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Signal.Rate">"Rate"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get rate(): number;
            set rate(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Signal.RssiThreshold">"RssiThreshold"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get rssi_threshold(): number;
            set rssi_threshold(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Signal.RssiThreshold">"RssiThreshold"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get rssiThreshold(): number;
            set rssiThreshold(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Signal.Umts">"Umts"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get umts(): GLib.Variant;
            set umts(val: GLib.Variant);

            // Inherited methods
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            init_async(io_priority: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             * @returns %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present.
             */
            init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Finishes the async construction for the various g_async_initable_new
             * calls, returning the created object or %NULL on error.
             * @param res the #GAsyncResult from the callback
             * @returns a newly created #GObject,      or %NULL on error. Free with g_object_unref().
             */
            new_finish(res: Gio.AsyncResult): GdbusModemSignalProxy;
            // Conflicted with Gio.DBusProxy.new_finish
            new_finish(...args: never[]): any;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            vfunc_init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             */
            vfunc_init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             * @returns A #GDBusObject or %NULL. The returned reference should be freed with g_object_unref().
             */
            get_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             * @returns A #GDBusInterfaceInfo. Do not free.
             */
            get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            set_object(object?: Gio.DBusObject | null): void;
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             */
            vfunc_dup_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             */
            vfunc_get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            vfunc_set_object(object?: Gio.DBusObject | null): void;
            /**
             * Initializes the object implementing the interface.
             *
             * This method is intended for language bindings. If writing in C,
             * g_initable_new() should typically be used instead.
             *
             * The object must be initialized before any real use after initial
             * construction, either with this function or g_async_initable_init_async().
             *
             * Implementations may also support cancellation. If `cancellable` is not %NULL,
             * then initialization can be cancelled by triggering the cancellable object
             * from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
             * the object doesn't support cancellable initialization the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * If the object is not initialized, or initialization returns with an
             * error, then all operations on the object except g_object_ref() and
             * g_object_unref() are considered to be invalid, and have undefined
             * behaviour. See the [description][iface`Gio`.Initable#description] for more details.
             *
             * Callers should not assume that a class which implements #GInitable can be
             * initialized multiple times, unless the class explicitly documents itself as
             * supporting this. Generally, a class’ implementation of init() can assume
             * (and assert) that it will only be called once. Previously, this documentation
             * recommended all #GInitable implementations should be idempotent; that
             * recommendation was relaxed in GLib 2.54.
             *
             * If a class explicitly supports being initialized multiple times, it is
             * recommended that the method is idempotent: multiple calls with the same
             * arguments should return the same results. Only the first call initializes
             * the object; further calls return the result of the first call.
             *
             * One reason why a class might need to support idempotent initialization is if
             * it is designed to be used via the singleton pattern, with a
             * #GObjectClass.constructor that sometimes returns an existing instance.
             * In this pattern, a caller would expect to be able to call g_initable_init()
             * on the result of g_object_new(), regardless of whether it is in fact a new
             * instance.
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @returns %TRUE if successful. If an error has occurred, this function will     return %FALSE and set @error appropriately if present.
             */
            init(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Initializes the object implementing the interface.
             *
             * This method is intended for language bindings. If writing in C,
             * g_initable_new() should typically be used instead.
             *
             * The object must be initialized before any real use after initial
             * construction, either with this function or g_async_initable_init_async().
             *
             * Implementations may also support cancellation. If `cancellable` is not %NULL,
             * then initialization can be cancelled by triggering the cancellable object
             * from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
             * the object doesn't support cancellable initialization the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * If the object is not initialized, or initialization returns with an
             * error, then all operations on the object except g_object_ref() and
             * g_object_unref() are considered to be invalid, and have undefined
             * behaviour. See the [description][iface`Gio`.Initable#description] for more details.
             *
             * Callers should not assume that a class which implements #GInitable can be
             * initialized multiple times, unless the class explicitly documents itself as
             * supporting this. Generally, a class’ implementation of init() can assume
             * (and assert) that it will only be called once. Previously, this documentation
             * recommended all #GInitable implementations should be idempotent; that
             * recommendation was relaxed in GLib 2.54.
             *
             * If a class explicitly supports being initialized multiple times, it is
             * recommended that the method is idempotent: multiple calls with the same
             * arguments should return the same results. Only the first call initializes
             * the object; further calls return the result of the first call.
             *
             * One reason why a class might need to support idempotent initialization is if
             * it is designed to be used via the singleton pattern, with a
             * #GObjectClass.constructor that sometimes returns an existing instance.
             * In this pattern, a caller would expect to be able to call g_initable_init()
             * on the result of g_object_new(), regardless of whether it is in fact a new
             * instance.
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            vfunc_init(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Signal.Setup">Setup()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_signal_call_setup_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_signal_call_setup_sync() for the synchronous, blocking version of this method.
             * @param arg_rate Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_setup(arg_rate: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Signal.Setup">Setup()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_signal_call_setup_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_signal_call_setup_sync() for the synchronous, blocking version of this method.
             * @param arg_rate Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_setup(
                arg_rate: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Signal.Setup">Setup()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_signal_call_setup_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_signal_call_setup_sync() for the synchronous, blocking version of this method.
             * @param arg_rate Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_setup(
                arg_rate: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_signal_call_setup().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_signal_call_setup().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_setup_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Signal.Setup">Setup()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_signal_call_setup() for the asynchronous version of this method.
             * @param arg_rate Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_setup_sync(arg_rate: number, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Signal.SetupThresholds">SetupThresholds()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_signal_call_setup_thresholds_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_signal_call_setup_thresholds_sync() for the synchronous, blocking version of this method.
             * @param arg_settings Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_setup_thresholds(arg_settings: GLib.Variant, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Signal.SetupThresholds">SetupThresholds()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_signal_call_setup_thresholds_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_signal_call_setup_thresholds_sync() for the synchronous, blocking version of this method.
             * @param arg_settings Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_setup_thresholds(
                arg_settings: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Signal.SetupThresholds">SetupThresholds()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_signal_call_setup_thresholds_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_signal_call_setup_thresholds_sync() for the synchronous, blocking version of this method.
             * @param arg_settings Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_setup_thresholds(
                arg_settings: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_signal_call_setup_thresholds().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_signal_call_setup_thresholds().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_setup_thresholds_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Signal.SetupThresholds">SetupThresholds()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_signal_call_setup_thresholds() for the asynchronous version of this method.
             * @param arg_settings Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_setup_thresholds_sync(arg_settings: GLib.Variant, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Signal.Setup">Setup()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_setup(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Signal.SetupThresholds">SetupThresholds()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_setup_thresholds(invocation: Gio.DBusMethodInvocation): void;
            vfunc_handle_setup(invocation: Gio.DBusMethodInvocation, arg_rate: number): boolean;
            vfunc_handle_setup_thresholds(invocation: Gio.DBusMethodInvocation, arg_settings: GLib.Variant): boolean;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace GdbusModemSignalSkeleton {
            // Constructor properties interface

            interface ConstructorProps
                extends Gio.DBusInterfaceSkeleton.ConstructorProps,
                    Gio.DBusInterface.ConstructorProps,
                    GdbusModemSignal.ConstructorProps {}
        }

        /**
         * The #MmGdbusModemSignalSkeleton structure contains only private data and should only be accessed using the provided API.
         */
        class GdbusModemSignalSkeleton
            extends Gio.DBusInterfaceSkeleton
            implements Gio.DBusInterface, GdbusModemSignal
        {
            static $gtype: GObject.GType<GdbusModemSignalSkeleton>;

            // Constructors

            constructor(properties?: Partial<GdbusModemSignalSkeleton.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static ['new'](): GdbusModemSignalSkeleton;

            // Inherited properties
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Signal.Cdma">"Cdma"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get cdma(): GLib.Variant;
            set cdma(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Signal.ErrorRateThreshold">"ErrorRateThreshold"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get error_rate_threshold(): boolean;
            set error_rate_threshold(val: boolean);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Signal.ErrorRateThreshold">"ErrorRateThreshold"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get errorRateThreshold(): boolean;
            set errorRateThreshold(val: boolean);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Signal.Evdo">"Evdo"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get evdo(): GLib.Variant;
            set evdo(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Signal.Gsm">"Gsm"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get gsm(): GLib.Variant;
            set gsm(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Signal.Lte">"Lte"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get lte(): GLib.Variant;
            set lte(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Signal.Nr5g">"Nr5g"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get nr5g(): GLib.Variant;
            set nr5g(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Signal.Rate">"Rate"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get rate(): number;
            set rate(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Signal.RssiThreshold">"RssiThreshold"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get rssi_threshold(): number;
            set rssi_threshold(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Signal.RssiThreshold">"RssiThreshold"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get rssiThreshold(): number;
            set rssiThreshold(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Signal.Umts">"Umts"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get umts(): GLib.Variant;
            set umts(val: GLib.Variant);

            // Inherited methods
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             * @returns A #GDBusObject or %NULL. The returned reference should be freed with g_object_unref().
             */
            get_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             * @returns A #GDBusInterfaceInfo. Do not free.
             */
            get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            set_object(object?: Gio.DBusObject | null): void;
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             */
            vfunc_dup_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             */
            vfunc_get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            vfunc_set_object(object?: Gio.DBusObject | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Signal.Setup">Setup()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_signal_call_setup_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_signal_call_setup_sync() for the synchronous, blocking version of this method.
             * @param arg_rate Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_setup(arg_rate: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Signal.Setup">Setup()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_signal_call_setup_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_signal_call_setup_sync() for the synchronous, blocking version of this method.
             * @param arg_rate Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_setup(
                arg_rate: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Signal.Setup">Setup()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_signal_call_setup_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_signal_call_setup_sync() for the synchronous, blocking version of this method.
             * @param arg_rate Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_setup(
                arg_rate: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_signal_call_setup().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_signal_call_setup().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_setup_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Signal.Setup">Setup()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_signal_call_setup() for the asynchronous version of this method.
             * @param arg_rate Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_setup_sync(arg_rate: number, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Signal.SetupThresholds">SetupThresholds()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_signal_call_setup_thresholds_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_signal_call_setup_thresholds_sync() for the synchronous, blocking version of this method.
             * @param arg_settings Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_setup_thresholds(arg_settings: GLib.Variant, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Signal.SetupThresholds">SetupThresholds()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_signal_call_setup_thresholds_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_signal_call_setup_thresholds_sync() for the synchronous, blocking version of this method.
             * @param arg_settings Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_setup_thresholds(
                arg_settings: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Signal.SetupThresholds">SetupThresholds()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_signal_call_setup_thresholds_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_signal_call_setup_thresholds_sync() for the synchronous, blocking version of this method.
             * @param arg_settings Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_setup_thresholds(
                arg_settings: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_signal_call_setup_thresholds().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_signal_call_setup_thresholds().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_setup_thresholds_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Signal.SetupThresholds">SetupThresholds()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_signal_call_setup_thresholds() for the asynchronous version of this method.
             * @param arg_settings Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_setup_thresholds_sync(arg_settings: GLib.Variant, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Signal.Setup">Setup()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_setup(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Signal.SetupThresholds">SetupThresholds()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_setup_thresholds(invocation: Gio.DBusMethodInvocation): void;
            vfunc_handle_setup(invocation: Gio.DBusMethodInvocation, arg_rate: number): boolean;
            vfunc_handle_setup_thresholds(invocation: Gio.DBusMethodInvocation, arg_settings: GLib.Variant): boolean;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace GdbusModemSimpleProxy {
            // Constructor properties interface

            interface ConstructorProps
                extends Gio.DBusProxy.ConstructorProps,
                    Gio.AsyncInitable.ConstructorProps,
                    Gio.DBusInterface.ConstructorProps,
                    Gio.Initable.ConstructorProps,
                    GdbusModemSimple.ConstructorProps {}
        }

        /**
         * The #MmGdbusModemSimpleProxy structure contains only private data and should only be accessed using the provided API.
         */
        class GdbusModemSimpleProxy
            extends Gio.DBusProxy
            implements Gio.AsyncInitable<GdbusModemSimpleProxy>, Gio.DBusInterface, Gio.Initable, GdbusModemSimple
        {
            static $gtype: GObject.GType<GdbusModemSimpleProxy>;

            // Constructors

            constructor(properties?: Partial<GdbusModemSimpleProxy.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static new_finish(res: Gio.AsyncResult): GdbusModemSimpleProxy;
            // Conflicted with Gio.AsyncInitable.new_finish

            static new_finish(...args: never[]): any;

            static new_for_bus_finish(res: Gio.AsyncResult): GdbusModemSimpleProxy;

            static new_for_bus_sync(
                bus_type: Gio.BusType,
                flags: Gio.DBusProxyFlags,
                name: string,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
            ): GdbusModemSimpleProxy;
            // Conflicted with Gio.DBusProxy.new_for_bus_sync

            static new_for_bus_sync(...args: never[]): any;

            static new_sync(
                connection: Gio.DBusConnection,
                flags: Gio.DBusProxyFlags,
                name: string | null,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
            ): GdbusModemSimpleProxy;
            // Conflicted with Gio.DBusProxy.new_sync

            static new_sync(...args: never[]): any;

            // Static methods

            /**
             * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Simple.top_of_page">org.freedesktop.ModemManager1.Modem.Simple</link>. See g_dbus_proxy_new() for more details.
             *
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_simple_proxy_new_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_simple_proxy_new_sync() for the synchronous, blocking version of this constructor.
             * @param connection A #GDBusConnection.
             * @param flags Flags from the #GDBusProxyFlags enumeration.
             * @param name A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
             * @param object_path An object path.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied.
             */
            static ['new'](
                connection: Gio.DBusConnection,
                flags: Gio.DBusProxyFlags,
                name: string | null,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<GdbusModemSimpleProxy> | null,
            ): void;
            // Conflicted with Gio.DBusProxy.new
            static ['new'](...args: never[]): any;
            /**
             * Like mm_gdbus_modem_simple_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
             *
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_simple_proxy_new_for_bus_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_simple_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
             * @param bus_type A #GBusType.
             * @param flags Flags from the #GDBusProxyFlags enumeration.
             * @param name A bus name (well-known or unique).
             * @param object_path An object path.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied.
             */
            static new_for_bus(
                bus_type: Gio.BusType,
                flags: Gio.DBusProxyFlags,
                name: string,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<GdbusModemSimpleProxy> | null,
            ): void;
            // Conflicted with Gio.DBusProxy.new_for_bus
            static new_for_bus(...args: never[]): any;

            // Inherited methods
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            init_async(io_priority: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             * @returns %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present.
             */
            init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Finishes the async construction for the various g_async_initable_new
             * calls, returning the created object or %NULL on error.
             * @param res the #GAsyncResult from the callback
             * @returns a newly created #GObject,      or %NULL on error. Free with g_object_unref().
             */
            new_finish(res: Gio.AsyncResult): GdbusModemSimpleProxy;
            // Conflicted with Gio.DBusProxy.new_finish
            new_finish(...args: never[]): any;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            vfunc_init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             */
            vfunc_init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             * @returns A #GDBusObject or %NULL. The returned reference should be freed with g_object_unref().
             */
            get_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             * @returns A #GDBusInterfaceInfo. Do not free.
             */
            get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            set_object(object?: Gio.DBusObject | null): void;
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             */
            vfunc_dup_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             */
            vfunc_get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            vfunc_set_object(object?: Gio.DBusObject | null): void;
            /**
             * Initializes the object implementing the interface.
             *
             * This method is intended for language bindings. If writing in C,
             * g_initable_new() should typically be used instead.
             *
             * The object must be initialized before any real use after initial
             * construction, either with this function or g_async_initable_init_async().
             *
             * Implementations may also support cancellation. If `cancellable` is not %NULL,
             * then initialization can be cancelled by triggering the cancellable object
             * from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
             * the object doesn't support cancellable initialization the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * If the object is not initialized, or initialization returns with an
             * error, then all operations on the object except g_object_ref() and
             * g_object_unref() are considered to be invalid, and have undefined
             * behaviour. See the [description][iface`Gio`.Initable#description] for more details.
             *
             * Callers should not assume that a class which implements #GInitable can be
             * initialized multiple times, unless the class explicitly documents itself as
             * supporting this. Generally, a class’ implementation of init() can assume
             * (and assert) that it will only be called once. Previously, this documentation
             * recommended all #GInitable implementations should be idempotent; that
             * recommendation was relaxed in GLib 2.54.
             *
             * If a class explicitly supports being initialized multiple times, it is
             * recommended that the method is idempotent: multiple calls with the same
             * arguments should return the same results. Only the first call initializes
             * the object; further calls return the result of the first call.
             *
             * One reason why a class might need to support idempotent initialization is if
             * it is designed to be used via the singleton pattern, with a
             * #GObjectClass.constructor that sometimes returns an existing instance.
             * In this pattern, a caller would expect to be able to call g_initable_init()
             * on the result of g_object_new(), regardless of whether it is in fact a new
             * instance.
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @returns %TRUE if successful. If an error has occurred, this function will     return %FALSE and set @error appropriately if present.
             */
            init(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Initializes the object implementing the interface.
             *
             * This method is intended for language bindings. If writing in C,
             * g_initable_new() should typically be used instead.
             *
             * The object must be initialized before any real use after initial
             * construction, either with this function or g_async_initable_init_async().
             *
             * Implementations may also support cancellation. If `cancellable` is not %NULL,
             * then initialization can be cancelled by triggering the cancellable object
             * from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
             * the object doesn't support cancellable initialization the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * If the object is not initialized, or initialization returns with an
             * error, then all operations on the object except g_object_ref() and
             * g_object_unref() are considered to be invalid, and have undefined
             * behaviour. See the [description][iface`Gio`.Initable#description] for more details.
             *
             * Callers should not assume that a class which implements #GInitable can be
             * initialized multiple times, unless the class explicitly documents itself as
             * supporting this. Generally, a class’ implementation of init() can assume
             * (and assert) that it will only be called once. Previously, this documentation
             * recommended all #GInitable implementations should be idempotent; that
             * recommendation was relaxed in GLib 2.54.
             *
             * If a class explicitly supports being initialized multiple times, it is
             * recommended that the method is idempotent: multiple calls with the same
             * arguments should return the same results. Only the first call initializes
             * the object; further calls return the result of the first call.
             *
             * One reason why a class might need to support idempotent initialization is if
             * it is designed to be used via the singleton pattern, with a
             * #GObjectClass.constructor that sometimes returns an existing instance.
             * In this pattern, a caller would expect to be able to call g_initable_init()
             * on the result of g_object_new(), regardless of whether it is in fact a new
             * instance.
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            vfunc_init(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Simple.Connect">Connect()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_simple_call_connect_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_simple_call_connect_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_connect(arg_properties: GLib.Variant, cancellable?: Gio.Cancellable | null): Promise<string>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Simple.Connect">Connect()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_simple_call_connect_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_simple_call_connect_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_connect(
                arg_properties: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Simple.Connect">Connect()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_simple_call_connect_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_simple_call_connect_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_connect(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<string> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_simple_call_connect().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_simple_call_connect().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_connect_finish(res: Gio.AsyncResult): [boolean, string];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Simple.Connect">Connect()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_simple_call_connect() for the asynchronous version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_connect_sync(arg_properties: GLib.Variant, cancellable?: Gio.Cancellable | null): [boolean, string];
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Simple.Disconnect">Disconnect()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_simple_call_disconnect_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_simple_call_disconnect_sync() for the synchronous, blocking version of this method.
             * @param arg_bearer Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_disconnect(arg_bearer: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Simple.Disconnect">Disconnect()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_simple_call_disconnect_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_simple_call_disconnect_sync() for the synchronous, blocking version of this method.
             * @param arg_bearer Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_disconnect(
                arg_bearer: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Simple.Disconnect">Disconnect()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_simple_call_disconnect_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_simple_call_disconnect_sync() for the synchronous, blocking version of this method.
             * @param arg_bearer Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_disconnect(
                arg_bearer: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_simple_call_disconnect().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_simple_call_disconnect().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_disconnect_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Simple.Disconnect">Disconnect()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_simple_call_disconnect() for the asynchronous version of this method.
             * @param arg_bearer Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_disconnect_sync(arg_bearer: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Simple.GetStatus">GetStatus()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_simple_call_get_status_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_simple_call_get_status_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_get_status(cancellable?: Gio.Cancellable | null): Promise<GLib.Variant | null>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Simple.GetStatus">GetStatus()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_simple_call_get_status_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_simple_call_get_status_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_get_status(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Simple.GetStatus">GetStatus()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_simple_call_get_status_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_simple_call_get_status_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_get_status(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<GLib.Variant | null> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_simple_call_get_status().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_simple_call_get_status().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_get_status_finish(res: Gio.AsyncResult): [boolean, GLib.Variant | null];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Simple.GetStatus">GetStatus()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_simple_call_get_status() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_get_status_sync(cancellable?: Gio.Cancellable | null): [boolean, GLib.Variant | null];
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Simple.Connect">Connect()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param bearer Parameter to return.
             */
            complete_connect(invocation: Gio.DBusMethodInvocation, bearer: string): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Simple.Disconnect">Disconnect()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_disconnect(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Simple.GetStatus">GetStatus()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param properties Parameter to return.
             */
            complete_get_status(invocation: Gio.DBusMethodInvocation, properties: GLib.Variant): void;
            vfunc_handle_connect(invocation: Gio.DBusMethodInvocation, arg_properties: GLib.Variant): boolean;
            vfunc_handle_disconnect(invocation: Gio.DBusMethodInvocation, arg_bearer: string): boolean;
            vfunc_handle_get_status(invocation: Gio.DBusMethodInvocation): boolean;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace GdbusModemSimpleSkeleton {
            // Constructor properties interface

            interface ConstructorProps
                extends Gio.DBusInterfaceSkeleton.ConstructorProps,
                    Gio.DBusInterface.ConstructorProps,
                    GdbusModemSimple.ConstructorProps {}
        }

        /**
         * The #MmGdbusModemSimpleSkeleton structure contains only private data and should only be accessed using the provided API.
         */
        class GdbusModemSimpleSkeleton
            extends Gio.DBusInterfaceSkeleton
            implements Gio.DBusInterface, GdbusModemSimple
        {
            static $gtype: GObject.GType<GdbusModemSimpleSkeleton>;

            // Constructors

            constructor(properties?: Partial<GdbusModemSimpleSkeleton.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static ['new'](): GdbusModemSimpleSkeleton;

            // Inherited methods
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             * @returns A #GDBusObject or %NULL. The returned reference should be freed with g_object_unref().
             */
            get_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             * @returns A #GDBusInterfaceInfo. Do not free.
             */
            get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            set_object(object?: Gio.DBusObject | null): void;
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             */
            vfunc_dup_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             */
            vfunc_get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            vfunc_set_object(object?: Gio.DBusObject | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Simple.Connect">Connect()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_simple_call_connect_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_simple_call_connect_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_connect(arg_properties: GLib.Variant, cancellable?: Gio.Cancellable | null): Promise<string>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Simple.Connect">Connect()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_simple_call_connect_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_simple_call_connect_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_connect(
                arg_properties: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Simple.Connect">Connect()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_simple_call_connect_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_simple_call_connect_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_connect(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<string> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_simple_call_connect().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_simple_call_connect().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_connect_finish(res: Gio.AsyncResult): [boolean, string];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Simple.Connect">Connect()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_simple_call_connect() for the asynchronous version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_connect_sync(arg_properties: GLib.Variant, cancellable?: Gio.Cancellable | null): [boolean, string];
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Simple.Disconnect">Disconnect()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_simple_call_disconnect_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_simple_call_disconnect_sync() for the synchronous, blocking version of this method.
             * @param arg_bearer Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_disconnect(arg_bearer: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Simple.Disconnect">Disconnect()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_simple_call_disconnect_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_simple_call_disconnect_sync() for the synchronous, blocking version of this method.
             * @param arg_bearer Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_disconnect(
                arg_bearer: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Simple.Disconnect">Disconnect()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_simple_call_disconnect_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_simple_call_disconnect_sync() for the synchronous, blocking version of this method.
             * @param arg_bearer Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_disconnect(
                arg_bearer: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_simple_call_disconnect().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_simple_call_disconnect().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_disconnect_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Simple.Disconnect">Disconnect()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_simple_call_disconnect() for the asynchronous version of this method.
             * @param arg_bearer Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_disconnect_sync(arg_bearer: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Simple.GetStatus">GetStatus()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_simple_call_get_status_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_simple_call_get_status_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_get_status(cancellable?: Gio.Cancellable | null): Promise<GLib.Variant | null>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Simple.GetStatus">GetStatus()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_simple_call_get_status_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_simple_call_get_status_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_get_status(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Simple.GetStatus">GetStatus()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_simple_call_get_status_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_simple_call_get_status_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_get_status(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<GLib.Variant | null> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_simple_call_get_status().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_simple_call_get_status().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_get_status_finish(res: Gio.AsyncResult): [boolean, GLib.Variant | null];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Simple.GetStatus">GetStatus()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_simple_call_get_status() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_get_status_sync(cancellable?: Gio.Cancellable | null): [boolean, GLib.Variant | null];
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Simple.Connect">Connect()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param bearer Parameter to return.
             */
            complete_connect(invocation: Gio.DBusMethodInvocation, bearer: string): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Simple.Disconnect">Disconnect()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_disconnect(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Simple.GetStatus">GetStatus()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param properties Parameter to return.
             */
            complete_get_status(invocation: Gio.DBusMethodInvocation, properties: GLib.Variant): void;
            vfunc_handle_connect(invocation: Gio.DBusMethodInvocation, arg_properties: GLib.Variant): boolean;
            vfunc_handle_disconnect(invocation: Gio.DBusMethodInvocation, arg_bearer: string): boolean;
            vfunc_handle_get_status(invocation: Gio.DBusMethodInvocation): boolean;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace GdbusModemSkeleton {
            // Constructor properties interface

            interface ConstructorProps
                extends Gio.DBusInterfaceSkeleton.ConstructorProps,
                    Gio.DBusInterface.ConstructorProps,
                    GdbusModem.ConstructorProps {}
        }

        /**
         * The #MmGdbusModemSkeleton structure contains only private data and should only be accessed using the provided API.
         */
        class GdbusModemSkeleton extends Gio.DBusInterfaceSkeleton implements Gio.DBusInterface, GdbusModem {
            static $gtype: GObject.GType<GdbusModemSkeleton>;

            // Constructors

            constructor(properties?: Partial<GdbusModemSkeleton.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static ['new'](): GdbusModemSkeleton;

            // Inherited properties
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.AccessTechnologies">"AccessTechnologies"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get access_technologies(): number;
            set access_technologies(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.AccessTechnologies">"AccessTechnologies"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get accessTechnologies(): number;
            set accessTechnologies(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.Bearers">"Bearers"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get bearers(): string[];
            set bearers(val: string[]);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.CarrierConfiguration">"CarrierConfiguration"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get carrier_configuration(): string;
            set carrier_configuration(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.CarrierConfiguration">"CarrierConfiguration"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get carrierConfiguration(): string;
            set carrierConfiguration(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.CarrierConfigurationRevision">"CarrierConfigurationRevision"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get carrier_configuration_revision(): string;
            set carrier_configuration_revision(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.CarrierConfigurationRevision">"CarrierConfigurationRevision"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get carrierConfigurationRevision(): string;
            set carrierConfigurationRevision(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.CurrentBands">"CurrentBands"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get current_bands(): GLib.Variant;
            set current_bands(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.CurrentBands">"CurrentBands"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get currentBands(): GLib.Variant;
            set currentBands(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.CurrentCapabilities">"CurrentCapabilities"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get current_capabilities(): number;
            set current_capabilities(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.CurrentCapabilities">"CurrentCapabilities"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get currentCapabilities(): number;
            set currentCapabilities(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.CurrentModes">"CurrentModes"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get current_modes(): GLib.Variant;
            set current_modes(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.CurrentModes">"CurrentModes"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get currentModes(): GLib.Variant;
            set currentModes(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.Device">"Device"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get device(): string;
            set device(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.DeviceIdentifier">"DeviceIdentifier"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get device_identifier(): string;
            set device_identifier(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.DeviceIdentifier">"DeviceIdentifier"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get deviceIdentifier(): string;
            set deviceIdentifier(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.Drivers">"Drivers"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get drivers(): string[];
            set drivers(val: string[]);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.EquipmentIdentifier">"EquipmentIdentifier"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get equipment_identifier(): string;
            set equipment_identifier(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.EquipmentIdentifier">"EquipmentIdentifier"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get equipmentIdentifier(): string;
            set equipmentIdentifier(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.HardwareRevision">"HardwareRevision"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get hardware_revision(): string;
            set hardware_revision(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.HardwareRevision">"HardwareRevision"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get hardwareRevision(): string;
            set hardwareRevision(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.Manufacturer">"Manufacturer"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get manufacturer(): string;
            set manufacturer(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.MaxActiveBearers">"MaxActiveBearers"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get max_active_bearers(): number;
            set max_active_bearers(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.MaxActiveBearers">"MaxActiveBearers"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get maxActiveBearers(): number;
            set maxActiveBearers(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.MaxActiveMultiplexedBearers">"MaxActiveMultiplexedBearers"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get max_active_multiplexed_bearers(): number;
            set max_active_multiplexed_bearers(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.MaxActiveMultiplexedBearers">"MaxActiveMultiplexedBearers"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get maxActiveMultiplexedBearers(): number;
            set maxActiveMultiplexedBearers(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.MaxBearers">"MaxBearers"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get max_bearers(): number;
            set max_bearers(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.MaxBearers">"MaxBearers"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get maxBearers(): number;
            set maxBearers(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.Model">"Model"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get model(): string;
            set model(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.OwnNumbers">"OwnNumbers"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get own_numbers(): string[];
            set own_numbers(val: string[]);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.OwnNumbers">"OwnNumbers"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get ownNumbers(): string[];
            set ownNumbers(val: string[]);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.Physdev">"Physdev"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get physdev(): string;
            set physdev(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.Plugin">"Plugin"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get plugin(): string;
            set plugin(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.Ports">"Ports"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get ports(): GLib.Variant;
            set ports(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.PowerState">"PowerState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get power_state(): number;
            set power_state(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.PowerState">"PowerState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get powerState(): number;
            set powerState(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.PrimaryPort">"PrimaryPort"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get primary_port(): string;
            set primary_port(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.PrimaryPort">"PrimaryPort"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get primaryPort(): string;
            set primaryPort(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.PrimarySimSlot">"PrimarySimSlot"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get primary_sim_slot(): number;
            set primary_sim_slot(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.PrimarySimSlot">"PrimarySimSlot"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get primarySimSlot(): number;
            set primarySimSlot(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.Revision">"Revision"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get revision(): string;
            set revision(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.SignalQuality">"SignalQuality"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get signal_quality(): GLib.Variant;
            set signal_quality(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.SignalQuality">"SignalQuality"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get signalQuality(): GLib.Variant;
            set signalQuality(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.Sim">"Sim"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get sim(): string;
            set sim(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.SimSlots">"SimSlots"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get sim_slots(): string[];
            set sim_slots(val: string[]);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.SimSlots">"SimSlots"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get simSlots(): string[];
            set simSlots(val: string[]);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.State">"State"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get state(): number;
            set state(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.StateFailedReason">"StateFailedReason"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get state_failed_reason(): number;
            set state_failed_reason(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.StateFailedReason">"StateFailedReason"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get stateFailedReason(): number;
            set stateFailedReason(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.SupportedBands">"SupportedBands"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get supported_bands(): GLib.Variant;
            set supported_bands(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.SupportedBands">"SupportedBands"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get supportedBands(): GLib.Variant;
            set supportedBands(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.SupportedCapabilities">"SupportedCapabilities"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get supported_capabilities(): GLib.Variant;
            set supported_capabilities(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.SupportedCapabilities">"SupportedCapabilities"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get supportedCapabilities(): GLib.Variant;
            set supportedCapabilities(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.SupportedIpFamilies">"SupportedIpFamilies"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get supported_ip_families(): number;
            set supported_ip_families(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.SupportedIpFamilies">"SupportedIpFamilies"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get supportedIpFamilies(): number;
            set supportedIpFamilies(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.SupportedModes">"SupportedModes"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get supported_modes(): GLib.Variant;
            set supported_modes(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.SupportedModes">"SupportedModes"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get supportedModes(): GLib.Variant;
            set supportedModes(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.UnlockRequired">"UnlockRequired"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get unlock_required(): number;
            set unlock_required(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.UnlockRequired">"UnlockRequired"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get unlockRequired(): number;
            set unlockRequired(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.UnlockRetries">"UnlockRetries"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get unlock_retries(): GLib.Variant;
            set unlock_retries(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.UnlockRetries">"UnlockRetries"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get unlockRetries(): GLib.Variant;
            set unlockRetries(val: GLib.Variant);

            // Inherited methods
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             * @returns A #GDBusObject or %NULL. The returned reference should be freed with g_object_unref().
             */
            get_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             * @returns A #GDBusInterfaceInfo. Do not free.
             */
            get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            set_object(object?: Gio.DBusObject | null): void;
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             */
            vfunc_dup_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             */
            vfunc_get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            vfunc_set_object(object?: Gio.DBusObject | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.Command">Command()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_command_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_command_sync() for the synchronous, blocking version of this method.
             * @param arg_cmd Argument to pass with the method invocation.
             * @param arg_timeout Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_command(arg_cmd: string, arg_timeout: number, cancellable?: Gio.Cancellable | null): Promise<string>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.Command">Command()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_command_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_command_sync() for the synchronous, blocking version of this method.
             * @param arg_cmd Argument to pass with the method invocation.
             * @param arg_timeout Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_command(
                arg_cmd: string,
                arg_timeout: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.Command">Command()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_command_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_command_sync() for the synchronous, blocking version of this method.
             * @param arg_cmd Argument to pass with the method invocation.
             * @param arg_timeout Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_command(
                arg_cmd: string,
                arg_timeout: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<string> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_call_command().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_call_command().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_command_finish(res: Gio.AsyncResult): [boolean, string];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.Command">Command()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_call_command() for the asynchronous version of this method.
             * @param arg_cmd Argument to pass with the method invocation.
             * @param arg_timeout Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_command_sync(
                arg_cmd: string,
                arg_timeout: number,
                cancellable?: Gio.Cancellable | null,
            ): [boolean, string];
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.CreateBearer">CreateBearer()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_create_bearer_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_create_bearer_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_create_bearer(arg_properties: GLib.Variant, cancellable?: Gio.Cancellable | null): Promise<string>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.CreateBearer">CreateBearer()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_create_bearer_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_create_bearer_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_create_bearer(
                arg_properties: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.CreateBearer">CreateBearer()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_create_bearer_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_create_bearer_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_create_bearer(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<string> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_call_create_bearer().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_call_create_bearer().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_create_bearer_finish(res: Gio.AsyncResult): [boolean, string];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.CreateBearer">CreateBearer()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_call_create_bearer() for the asynchronous version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_create_bearer_sync(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
            ): [boolean, string];
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.DeleteBearer">DeleteBearer()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_delete_bearer_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_delete_bearer_sync() for the synchronous, blocking version of this method.
             * @param arg_bearer Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_delete_bearer(arg_bearer: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.DeleteBearer">DeleteBearer()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_delete_bearer_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_delete_bearer_sync() for the synchronous, blocking version of this method.
             * @param arg_bearer Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_delete_bearer(
                arg_bearer: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.DeleteBearer">DeleteBearer()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_delete_bearer_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_delete_bearer_sync() for the synchronous, blocking version of this method.
             * @param arg_bearer Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_delete_bearer(
                arg_bearer: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_call_delete_bearer().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_call_delete_bearer().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_delete_bearer_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.DeleteBearer">DeleteBearer()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_call_delete_bearer() for the asynchronous version of this method.
             * @param arg_bearer Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_delete_bearer_sync(arg_bearer: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.Enable">Enable()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_enable_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_enable_sync() for the synchronous, blocking version of this method.
             * @param arg_enable Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_enable(arg_enable: boolean, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.Enable">Enable()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_enable_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_enable_sync() for the synchronous, blocking version of this method.
             * @param arg_enable Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_enable(
                arg_enable: boolean,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.Enable">Enable()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_enable_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_enable_sync() for the synchronous, blocking version of this method.
             * @param arg_enable Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_enable(
                arg_enable: boolean,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_call_enable().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_call_enable().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_enable_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.Enable">Enable()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_call_enable() for the asynchronous version of this method.
             * @param arg_enable Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_enable_sync(arg_enable: boolean, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.FactoryReset">FactoryReset()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_factory_reset_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_factory_reset_sync() for the synchronous, blocking version of this method.
             * @param arg_code Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_factory_reset(arg_code: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.FactoryReset">FactoryReset()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_factory_reset_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_factory_reset_sync() for the synchronous, blocking version of this method.
             * @param arg_code Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_factory_reset(
                arg_code: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.FactoryReset">FactoryReset()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_factory_reset_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_factory_reset_sync() for the synchronous, blocking version of this method.
             * @param arg_code Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_factory_reset(
                arg_code: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_call_factory_reset().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_call_factory_reset().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_factory_reset_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.FactoryReset">FactoryReset()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_call_factory_reset() for the asynchronous version of this method.
             * @param arg_code Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_factory_reset_sync(arg_code: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.GetCellInfo">GetCellInfo()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_get_cell_info_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_get_cell_info_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_get_cell_info(cancellable?: Gio.Cancellable | null): Promise<GLib.Variant | null>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.GetCellInfo">GetCellInfo()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_get_cell_info_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_get_cell_info_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_get_cell_info(
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.GetCellInfo">GetCellInfo()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_get_cell_info_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_get_cell_info_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_get_cell_info(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<GLib.Variant | null> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_call_get_cell_info().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_call_get_cell_info().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_get_cell_info_finish(res: Gio.AsyncResult): [boolean, GLib.Variant | null];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.GetCellInfo">GetCellInfo()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_call_get_cell_info() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_get_cell_info_sync(cancellable?: Gio.Cancellable | null): [boolean, GLib.Variant | null];
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.ListBearers">ListBearers()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_list_bearers_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_list_bearers_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_list_bearers(cancellable?: Gio.Cancellable | null): Promise<string[] | null>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.ListBearers">ListBearers()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_list_bearers_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_list_bearers_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_list_bearers(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.ListBearers">ListBearers()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_list_bearers_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_list_bearers_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_list_bearers(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<string[] | null> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_call_list_bearers().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_call_list_bearers().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_list_bearers_finish(res: Gio.AsyncResult): [boolean, string[] | null];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.ListBearers">ListBearers()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_call_list_bearers() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_list_bearers_sync(cancellable?: Gio.Cancellable | null): [boolean, string[] | null];
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.Reset">Reset()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_reset_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_reset_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_reset(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.Reset">Reset()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_reset_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_reset_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_reset(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.Reset">Reset()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_reset_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_reset_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_reset(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_call_reset().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_call_reset().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_reset_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.Reset">Reset()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_call_reset() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_reset_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetCurrentBands">SetCurrentBands()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_set_current_bands_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_set_current_bands_sync() for the synchronous, blocking version of this method.
             * @param arg_bands Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set_current_bands(arg_bands: GLib.Variant, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetCurrentBands">SetCurrentBands()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_set_current_bands_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_set_current_bands_sync() for the synchronous, blocking version of this method.
             * @param arg_bands Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_current_bands(
                arg_bands: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetCurrentBands">SetCurrentBands()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_set_current_bands_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_set_current_bands_sync() for the synchronous, blocking version of this method.
             * @param arg_bands Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_current_bands(
                arg_bands: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_call_set_current_bands().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_call_set_current_bands().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_current_bands_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetCurrentBands">SetCurrentBands()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_call_set_current_bands() for the asynchronous version of this method.
             * @param arg_bands Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_current_bands_sync(arg_bands: GLib.Variant, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetCurrentCapabilities">SetCurrentCapabilities()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_set_current_capabilities_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_set_current_capabilities_sync() for the synchronous, blocking version of this method.
             * @param arg_capabilities Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set_current_capabilities(
                arg_capabilities: number,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetCurrentCapabilities">SetCurrentCapabilities()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_set_current_capabilities_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_set_current_capabilities_sync() for the synchronous, blocking version of this method.
             * @param arg_capabilities Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_current_capabilities(
                arg_capabilities: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetCurrentCapabilities">SetCurrentCapabilities()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_set_current_capabilities_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_set_current_capabilities_sync() for the synchronous, blocking version of this method.
             * @param arg_capabilities Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_current_capabilities(
                arg_capabilities: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_call_set_current_capabilities().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_call_set_current_capabilities().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_current_capabilities_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetCurrentCapabilities">SetCurrentCapabilities()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_call_set_current_capabilities() for the asynchronous version of this method.
             * @param arg_capabilities Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_current_capabilities_sync(arg_capabilities: number, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetCurrentModes">SetCurrentModes()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_set_current_modes_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_set_current_modes_sync() for the synchronous, blocking version of this method.
             * @param arg_modes Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set_current_modes(arg_modes: GLib.Variant, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetCurrentModes">SetCurrentModes()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_set_current_modes_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_set_current_modes_sync() for the synchronous, blocking version of this method.
             * @param arg_modes Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_current_modes(
                arg_modes: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetCurrentModes">SetCurrentModes()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_set_current_modes_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_set_current_modes_sync() for the synchronous, blocking version of this method.
             * @param arg_modes Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_current_modes(
                arg_modes: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_call_set_current_modes().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_call_set_current_modes().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_current_modes_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetCurrentModes">SetCurrentModes()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_call_set_current_modes() for the asynchronous version of this method.
             * @param arg_modes Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_current_modes_sync(arg_modes: GLib.Variant, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetPowerState">SetPowerState()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_set_power_state_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_set_power_state_sync() for the synchronous, blocking version of this method.
             * @param arg_state Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set_power_state(arg_state: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetPowerState">SetPowerState()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_set_power_state_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_set_power_state_sync() for the synchronous, blocking version of this method.
             * @param arg_state Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_power_state(
                arg_state: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetPowerState">SetPowerState()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_set_power_state_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_set_power_state_sync() for the synchronous, blocking version of this method.
             * @param arg_state Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_power_state(
                arg_state: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_call_set_power_state().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_call_set_power_state().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_power_state_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetPowerState">SetPowerState()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_call_set_power_state() for the asynchronous version of this method.
             * @param arg_state Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_power_state_sync(arg_state: number, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetPrimarySimSlot">SetPrimarySimSlot()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_set_primary_sim_slot_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_set_primary_sim_slot_sync() for the synchronous, blocking version of this method.
             * @param arg_sim_slot Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set_primary_sim_slot(arg_sim_slot: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetPrimarySimSlot">SetPrimarySimSlot()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_set_primary_sim_slot_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_set_primary_sim_slot_sync() for the synchronous, blocking version of this method.
             * @param arg_sim_slot Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_primary_sim_slot(
                arg_sim_slot: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetPrimarySimSlot">SetPrimarySimSlot()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_set_primary_sim_slot_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_set_primary_sim_slot_sync() for the synchronous, blocking version of this method.
             * @param arg_sim_slot Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_primary_sim_slot(
                arg_sim_slot: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_call_set_primary_sim_slot().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_call_set_primary_sim_slot().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_primary_sim_slot_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetPrimarySimSlot">SetPrimarySimSlot()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_call_set_primary_sim_slot() for the asynchronous version of this method.
             * @param arg_sim_slot Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_primary_sim_slot_sync(arg_sim_slot: number, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.Command">Command()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param response Parameter to return.
             */
            complete_command(invocation: Gio.DBusMethodInvocation, response: string): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.CreateBearer">CreateBearer()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param path Parameter to return.
             */
            complete_create_bearer(invocation: Gio.DBusMethodInvocation, path: string): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.DeleteBearer">DeleteBearer()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_delete_bearer(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.Enable">Enable()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_enable(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.FactoryReset">FactoryReset()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_factory_reset(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.GetCellInfo">GetCellInfo()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param cell_info Parameter to return.
             */
            complete_get_cell_info(invocation: Gio.DBusMethodInvocation, cell_info: GLib.Variant): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.ListBearers">ListBearers()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param bearers Parameter to return.
             */
            complete_list_bearers(invocation: Gio.DBusMethodInvocation, bearers: string): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.Reset">Reset()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_reset(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetCurrentBands">SetCurrentBands()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_set_current_bands(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetCurrentCapabilities">SetCurrentCapabilities()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_set_current_capabilities(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetCurrentModes">SetCurrentModes()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_set_current_modes(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetPowerState">SetPowerState()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_set_power_state(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetPrimarySimSlot">SetPrimarySimSlot()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_set_primary_sim_slot(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Emits the <link linkend="gdbus-signal-org-freedesktop-ModemManager1-Modem.StateChanged">"StateChanged"</link> D-Bus signal.
             * @param arg_old Argument to pass with the signal.
             * @param arg_new Argument to pass with the signal.
             * @param arg_reason Argument to pass with the signal.
             */
            emit_state_changed(arg_old: number, arg_new: number, arg_reason: number): void;
            vfunc_handle_command(invocation: Gio.DBusMethodInvocation, arg_cmd: string, arg_timeout: number): boolean;
            vfunc_handle_create_bearer(invocation: Gio.DBusMethodInvocation, arg_properties: GLib.Variant): boolean;
            vfunc_handle_delete_bearer(invocation: Gio.DBusMethodInvocation, arg_bearer: string): boolean;
            vfunc_handle_enable(invocation: Gio.DBusMethodInvocation, arg_enable: boolean): boolean;
            vfunc_handle_factory_reset(invocation: Gio.DBusMethodInvocation, arg_code: string): boolean;
            vfunc_handle_get_cell_info(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_list_bearers(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_reset(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_set_current_bands(invocation: Gio.DBusMethodInvocation, arg_bands: GLib.Variant): boolean;
            vfunc_handle_set_current_capabilities(
                invocation: Gio.DBusMethodInvocation,
                arg_capabilities: number,
            ): boolean;
            vfunc_handle_set_current_modes(invocation: Gio.DBusMethodInvocation, arg_modes: GLib.Variant): boolean;
            vfunc_handle_set_power_state(invocation: Gio.DBusMethodInvocation, arg_state: number): boolean;
            vfunc_handle_set_primary_sim_slot(invocation: Gio.DBusMethodInvocation, arg_sim_slot: number): boolean;
            vfunc_state_changed(arg_old: number, arg_new: number, arg_reason: number): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace GdbusModemTimeProxy {
            // Constructor properties interface

            interface ConstructorProps
                extends Gio.DBusProxy.ConstructorProps,
                    Gio.AsyncInitable.ConstructorProps,
                    Gio.DBusInterface.ConstructorProps,
                    Gio.Initable.ConstructorProps,
                    GdbusModemTime.ConstructorProps {}
        }

        /**
         * The #MmGdbusModemTimeProxy structure contains only private data and should only be accessed using the provided API.
         */
        class GdbusModemTimeProxy
            extends Gio.DBusProxy
            implements Gio.AsyncInitable<GdbusModemTimeProxy>, Gio.DBusInterface, Gio.Initable, GdbusModemTime
        {
            static $gtype: GObject.GType<GdbusModemTimeProxy>;

            // Constructors

            constructor(properties?: Partial<GdbusModemTimeProxy.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static new_finish(res: Gio.AsyncResult): GdbusModemTimeProxy;
            // Conflicted with Gio.AsyncInitable.new_finish

            static new_finish(...args: never[]): any;

            static new_for_bus_finish(res: Gio.AsyncResult): GdbusModemTimeProxy;

            static new_for_bus_sync(
                bus_type: Gio.BusType,
                flags: Gio.DBusProxyFlags,
                name: string,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
            ): GdbusModemTimeProxy;
            // Conflicted with Gio.DBusProxy.new_for_bus_sync

            static new_for_bus_sync(...args: never[]): any;

            static new_sync(
                connection: Gio.DBusConnection,
                flags: Gio.DBusProxyFlags,
                name: string | null,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
            ): GdbusModemTimeProxy;
            // Conflicted with Gio.DBusProxy.new_sync

            static new_sync(...args: never[]): any;

            // Static methods

            /**
             * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Time.top_of_page">org.freedesktop.ModemManager1.Modem.Time</link>. See g_dbus_proxy_new() for more details.
             *
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_time_proxy_new_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_time_proxy_new_sync() for the synchronous, blocking version of this constructor.
             * @param connection A #GDBusConnection.
             * @param flags Flags from the #GDBusProxyFlags enumeration.
             * @param name A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
             * @param object_path An object path.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied.
             */
            static ['new'](
                connection: Gio.DBusConnection,
                flags: Gio.DBusProxyFlags,
                name: string | null,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<GdbusModemTimeProxy> | null,
            ): void;
            // Conflicted with Gio.DBusProxy.new
            static ['new'](...args: never[]): any;
            /**
             * Like mm_gdbus_modem_time_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
             *
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_time_proxy_new_for_bus_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_time_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
             * @param bus_type A #GBusType.
             * @param flags Flags from the #GDBusProxyFlags enumeration.
             * @param name A bus name (well-known or unique).
             * @param object_path An object path.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied.
             */
            static new_for_bus(
                bus_type: Gio.BusType,
                flags: Gio.DBusProxyFlags,
                name: string,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<GdbusModemTimeProxy> | null,
            ): void;
            // Conflicted with Gio.DBusProxy.new_for_bus
            static new_for_bus(...args: never[]): any;

            // Inherited properties
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Time.NetworkTimezone">"NetworkTimezone"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get network_timezone(): GLib.Variant;
            set network_timezone(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Time.NetworkTimezone">"NetworkTimezone"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get networkTimezone(): GLib.Variant;
            set networkTimezone(val: GLib.Variant);

            // Inherited methods
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            init_async(io_priority: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             * @returns %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present.
             */
            init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Finishes the async construction for the various g_async_initable_new
             * calls, returning the created object or %NULL on error.
             * @param res the #GAsyncResult from the callback
             * @returns a newly created #GObject,      or %NULL on error. Free with g_object_unref().
             */
            new_finish(res: Gio.AsyncResult): GdbusModemTimeProxy;
            // Conflicted with Gio.DBusProxy.new_finish
            new_finish(...args: never[]): any;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            vfunc_init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             */
            vfunc_init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             * @returns A #GDBusObject or %NULL. The returned reference should be freed with g_object_unref().
             */
            get_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             * @returns A #GDBusInterfaceInfo. Do not free.
             */
            get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            set_object(object?: Gio.DBusObject | null): void;
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             */
            vfunc_dup_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             */
            vfunc_get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            vfunc_set_object(object?: Gio.DBusObject | null): void;
            /**
             * Initializes the object implementing the interface.
             *
             * This method is intended for language bindings. If writing in C,
             * g_initable_new() should typically be used instead.
             *
             * The object must be initialized before any real use after initial
             * construction, either with this function or g_async_initable_init_async().
             *
             * Implementations may also support cancellation. If `cancellable` is not %NULL,
             * then initialization can be cancelled by triggering the cancellable object
             * from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
             * the object doesn't support cancellable initialization the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * If the object is not initialized, or initialization returns with an
             * error, then all operations on the object except g_object_ref() and
             * g_object_unref() are considered to be invalid, and have undefined
             * behaviour. See the [description][iface`Gio`.Initable#description] for more details.
             *
             * Callers should not assume that a class which implements #GInitable can be
             * initialized multiple times, unless the class explicitly documents itself as
             * supporting this. Generally, a class’ implementation of init() can assume
             * (and assert) that it will only be called once. Previously, this documentation
             * recommended all #GInitable implementations should be idempotent; that
             * recommendation was relaxed in GLib 2.54.
             *
             * If a class explicitly supports being initialized multiple times, it is
             * recommended that the method is idempotent: multiple calls with the same
             * arguments should return the same results. Only the first call initializes
             * the object; further calls return the result of the first call.
             *
             * One reason why a class might need to support idempotent initialization is if
             * it is designed to be used via the singleton pattern, with a
             * #GObjectClass.constructor that sometimes returns an existing instance.
             * In this pattern, a caller would expect to be able to call g_initable_init()
             * on the result of g_object_new(), regardless of whether it is in fact a new
             * instance.
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @returns %TRUE if successful. If an error has occurred, this function will     return %FALSE and set @error appropriately if present.
             */
            init(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Initializes the object implementing the interface.
             *
             * This method is intended for language bindings. If writing in C,
             * g_initable_new() should typically be used instead.
             *
             * The object must be initialized before any real use after initial
             * construction, either with this function or g_async_initable_init_async().
             *
             * Implementations may also support cancellation. If `cancellable` is not %NULL,
             * then initialization can be cancelled by triggering the cancellable object
             * from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
             * the object doesn't support cancellable initialization the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * If the object is not initialized, or initialization returns with an
             * error, then all operations on the object except g_object_ref() and
             * g_object_unref() are considered to be invalid, and have undefined
             * behaviour. See the [description][iface`Gio`.Initable#description] for more details.
             *
             * Callers should not assume that a class which implements #GInitable can be
             * initialized multiple times, unless the class explicitly documents itself as
             * supporting this. Generally, a class’ implementation of init() can assume
             * (and assert) that it will only be called once. Previously, this documentation
             * recommended all #GInitable implementations should be idempotent; that
             * recommendation was relaxed in GLib 2.54.
             *
             * If a class explicitly supports being initialized multiple times, it is
             * recommended that the method is idempotent: multiple calls with the same
             * arguments should return the same results. Only the first call initializes
             * the object; further calls return the result of the first call.
             *
             * One reason why a class might need to support idempotent initialization is if
             * it is designed to be used via the singleton pattern, with a
             * #GObjectClass.constructor that sometimes returns an existing instance.
             * In this pattern, a caller would expect to be able to call g_initable_init()
             * on the result of g_object_new(), regardless of whether it is in fact a new
             * instance.
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            vfunc_init(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Time.GetNetworkTime">GetNetworkTime()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_time_call_get_network_time_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_time_call_get_network_time_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_get_network_time(cancellable?: Gio.Cancellable | null): Promise<string>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Time.GetNetworkTime">GetNetworkTime()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_time_call_get_network_time_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_time_call_get_network_time_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_get_network_time(
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Time.GetNetworkTime">GetNetworkTime()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_time_call_get_network_time_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_time_call_get_network_time_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_get_network_time(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<string> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_time_call_get_network_time().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_time_call_get_network_time().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_get_network_time_finish(res: Gio.AsyncResult): [boolean, string];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Time.GetNetworkTime">GetNetworkTime()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_time_call_get_network_time() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_get_network_time_sync(cancellable?: Gio.Cancellable | null): [boolean, string];
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Time.GetNetworkTime">GetNetworkTime()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param time Parameter to return.
             */
            complete_get_network_time(invocation: Gio.DBusMethodInvocation, time: string): void;
            /**
             * Emits the <link linkend="gdbus-signal-org-freedesktop-ModemManager1-Modem-Time.NetworkTimeChanged">"NetworkTimeChanged"</link> D-Bus signal.
             * @param arg_time Argument to pass with the signal.
             */
            emit_network_time_changed(arg_time: string): void;
            vfunc_handle_get_network_time(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_network_time_changed(arg_time: string): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace GdbusModemTimeSkeleton {
            // Constructor properties interface

            interface ConstructorProps
                extends Gio.DBusInterfaceSkeleton.ConstructorProps,
                    Gio.DBusInterface.ConstructorProps,
                    GdbusModemTime.ConstructorProps {}
        }

        /**
         * The #MmGdbusModemTimeSkeleton structure contains only private data and should only be accessed using the provided API.
         */
        class GdbusModemTimeSkeleton extends Gio.DBusInterfaceSkeleton implements Gio.DBusInterface, GdbusModemTime {
            static $gtype: GObject.GType<GdbusModemTimeSkeleton>;

            // Constructors

            constructor(properties?: Partial<GdbusModemTimeSkeleton.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static ['new'](): GdbusModemTimeSkeleton;

            // Inherited properties
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Time.NetworkTimezone">"NetworkTimezone"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get network_timezone(): GLib.Variant;
            set network_timezone(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Time.NetworkTimezone">"NetworkTimezone"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get networkTimezone(): GLib.Variant;
            set networkTimezone(val: GLib.Variant);

            // Inherited methods
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             * @returns A #GDBusObject or %NULL. The returned reference should be freed with g_object_unref().
             */
            get_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             * @returns A #GDBusInterfaceInfo. Do not free.
             */
            get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            set_object(object?: Gio.DBusObject | null): void;
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             */
            vfunc_dup_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             */
            vfunc_get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            vfunc_set_object(object?: Gio.DBusObject | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Time.GetNetworkTime">GetNetworkTime()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_time_call_get_network_time_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_time_call_get_network_time_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_get_network_time(cancellable?: Gio.Cancellable | null): Promise<string>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Time.GetNetworkTime">GetNetworkTime()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_time_call_get_network_time_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_time_call_get_network_time_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_get_network_time(
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Time.GetNetworkTime">GetNetworkTime()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_time_call_get_network_time_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_time_call_get_network_time_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_get_network_time(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<string> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_time_call_get_network_time().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_time_call_get_network_time().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_get_network_time_finish(res: Gio.AsyncResult): [boolean, string];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Time.GetNetworkTime">GetNetworkTime()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_time_call_get_network_time() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_get_network_time_sync(cancellable?: Gio.Cancellable | null): [boolean, string];
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Time.GetNetworkTime">GetNetworkTime()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param time Parameter to return.
             */
            complete_get_network_time(invocation: Gio.DBusMethodInvocation, time: string): void;
            /**
             * Emits the <link linkend="gdbus-signal-org-freedesktop-ModemManager1-Modem-Time.NetworkTimeChanged">"NetworkTimeChanged"</link> D-Bus signal.
             * @param arg_time Argument to pass with the signal.
             */
            emit_network_time_changed(arg_time: string): void;
            vfunc_handle_get_network_time(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_network_time_changed(arg_time: string): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace GdbusModemVoiceProxy {
            // Constructor properties interface

            interface ConstructorProps
                extends Gio.DBusProxy.ConstructorProps,
                    Gio.AsyncInitable.ConstructorProps,
                    Gio.DBusInterface.ConstructorProps,
                    Gio.Initable.ConstructorProps,
                    GdbusModemVoice.ConstructorProps {}
        }

        /**
         * The #MmGdbusModemVoiceProxy structure contains only private data and should only be accessed using the provided API.
         */
        class GdbusModemVoiceProxy
            extends Gio.DBusProxy
            implements Gio.AsyncInitable<GdbusModemVoiceProxy>, Gio.DBusInterface, Gio.Initable, GdbusModemVoice
        {
            static $gtype: GObject.GType<GdbusModemVoiceProxy>;

            // Constructors

            constructor(properties?: Partial<GdbusModemVoiceProxy.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static new_finish(res: Gio.AsyncResult): GdbusModemVoiceProxy;
            // Conflicted with Gio.AsyncInitable.new_finish

            static new_finish(...args: never[]): any;

            static new_for_bus_finish(res: Gio.AsyncResult): GdbusModemVoiceProxy;

            static new_for_bus_sync(
                bus_type: Gio.BusType,
                flags: Gio.DBusProxyFlags,
                name: string,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
            ): GdbusModemVoiceProxy;
            // Conflicted with Gio.DBusProxy.new_for_bus_sync

            static new_for_bus_sync(...args: never[]): any;

            static new_sync(
                connection: Gio.DBusConnection,
                flags: Gio.DBusProxyFlags,
                name: string | null,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
            ): GdbusModemVoiceProxy;
            // Conflicted with Gio.DBusProxy.new_sync

            static new_sync(...args: never[]): any;

            // Static methods

            /**
             * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Voice.top_of_page">org.freedesktop.ModemManager1.Modem.Voice</link>. See g_dbus_proxy_new() for more details.
             *
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_proxy_new_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_proxy_new_sync() for the synchronous, blocking version of this constructor.
             * @param connection A #GDBusConnection.
             * @param flags Flags from the #GDBusProxyFlags enumeration.
             * @param name A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
             * @param object_path An object path.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied.
             */
            static ['new'](
                connection: Gio.DBusConnection,
                flags: Gio.DBusProxyFlags,
                name: string | null,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<GdbusModemVoiceProxy> | null,
            ): void;
            // Conflicted with Gio.DBusProxy.new
            static ['new'](...args: never[]): any;
            /**
             * Like mm_gdbus_modem_voice_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
             *
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_proxy_new_for_bus_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
             * @param bus_type A #GBusType.
             * @param flags Flags from the #GDBusProxyFlags enumeration.
             * @param name A bus name (well-known or unique).
             * @param object_path An object path.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied.
             */
            static new_for_bus(
                bus_type: Gio.BusType,
                flags: Gio.DBusProxyFlags,
                name: string,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<GdbusModemVoiceProxy> | null,
            ): void;
            // Conflicted with Gio.DBusProxy.new_for_bus
            static new_for_bus(...args: never[]): any;

            // Inherited properties
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Voice.Calls">"Calls"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get calls(): string[];
            set calls(val: string[]);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Voice.EmergencyOnly">"EmergencyOnly"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get emergency_only(): boolean;
            set emergency_only(val: boolean);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Voice.EmergencyOnly">"EmergencyOnly"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get emergencyOnly(): boolean;
            set emergencyOnly(val: boolean);

            // Inherited methods
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            init_async(io_priority: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             * @returns %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present.
             */
            init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Finishes the async construction for the various g_async_initable_new
             * calls, returning the created object or %NULL on error.
             * @param res the #GAsyncResult from the callback
             * @returns a newly created #GObject,      or %NULL on error. Free with g_object_unref().
             */
            new_finish(res: Gio.AsyncResult): GdbusModemVoiceProxy;
            // Conflicted with Gio.DBusProxy.new_finish
            new_finish(...args: never[]): any;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            vfunc_init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             */
            vfunc_init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             * @returns A #GDBusObject or %NULL. The returned reference should be freed with g_object_unref().
             */
            get_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             * @returns A #GDBusInterfaceInfo. Do not free.
             */
            get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            set_object(object?: Gio.DBusObject | null): void;
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             */
            vfunc_dup_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             */
            vfunc_get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            vfunc_set_object(object?: Gio.DBusObject | null): void;
            /**
             * Initializes the object implementing the interface.
             *
             * This method is intended for language bindings. If writing in C,
             * g_initable_new() should typically be used instead.
             *
             * The object must be initialized before any real use after initial
             * construction, either with this function or g_async_initable_init_async().
             *
             * Implementations may also support cancellation. If `cancellable` is not %NULL,
             * then initialization can be cancelled by triggering the cancellable object
             * from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
             * the object doesn't support cancellable initialization the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * If the object is not initialized, or initialization returns with an
             * error, then all operations on the object except g_object_ref() and
             * g_object_unref() are considered to be invalid, and have undefined
             * behaviour. See the [description][iface`Gio`.Initable#description] for more details.
             *
             * Callers should not assume that a class which implements #GInitable can be
             * initialized multiple times, unless the class explicitly documents itself as
             * supporting this. Generally, a class’ implementation of init() can assume
             * (and assert) that it will only be called once. Previously, this documentation
             * recommended all #GInitable implementations should be idempotent; that
             * recommendation was relaxed in GLib 2.54.
             *
             * If a class explicitly supports being initialized multiple times, it is
             * recommended that the method is idempotent: multiple calls with the same
             * arguments should return the same results. Only the first call initializes
             * the object; further calls return the result of the first call.
             *
             * One reason why a class might need to support idempotent initialization is if
             * it is designed to be used via the singleton pattern, with a
             * #GObjectClass.constructor that sometimes returns an existing instance.
             * In this pattern, a caller would expect to be able to call g_initable_init()
             * on the result of g_object_new(), regardless of whether it is in fact a new
             * instance.
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @returns %TRUE if successful. If an error has occurred, this function will     return %FALSE and set @error appropriately if present.
             */
            init(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Initializes the object implementing the interface.
             *
             * This method is intended for language bindings. If writing in C,
             * g_initable_new() should typically be used instead.
             *
             * The object must be initialized before any real use after initial
             * construction, either with this function or g_async_initable_init_async().
             *
             * Implementations may also support cancellation. If `cancellable` is not %NULL,
             * then initialization can be cancelled by triggering the cancellable object
             * from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
             * the object doesn't support cancellable initialization the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * If the object is not initialized, or initialization returns with an
             * error, then all operations on the object except g_object_ref() and
             * g_object_unref() are considered to be invalid, and have undefined
             * behaviour. See the [description][iface`Gio`.Initable#description] for more details.
             *
             * Callers should not assume that a class which implements #GInitable can be
             * initialized multiple times, unless the class explicitly documents itself as
             * supporting this. Generally, a class’ implementation of init() can assume
             * (and assert) that it will only be called once. Previously, this documentation
             * recommended all #GInitable implementations should be idempotent; that
             * recommendation was relaxed in GLib 2.54.
             *
             * If a class explicitly supports being initialized multiple times, it is
             * recommended that the method is idempotent: multiple calls with the same
             * arguments should return the same results. Only the first call initializes
             * the object; further calls return the result of the first call.
             *
             * One reason why a class might need to support idempotent initialization is if
             * it is designed to be used via the singleton pattern, with a
             * #GObjectClass.constructor that sometimes returns an existing instance.
             * In this pattern, a caller would expect to be able to call g_initable_init()
             * on the result of g_object_new(), regardless of whether it is in fact a new
             * instance.
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            vfunc_init(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.CallWaitingQuery">CallWaitingQuery()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_call_waiting_query_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_call_waiting_query_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_call_waiting_query(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.CallWaitingQuery">CallWaitingQuery()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_call_waiting_query_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_call_waiting_query_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_call_waiting_query(
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.CallWaitingQuery">CallWaitingQuery()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_call_waiting_query_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_call_waiting_query_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_call_waiting_query(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_voice_call_call_waiting_query().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_voice_call_call_waiting_query().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_call_waiting_query_finish(res: Gio.AsyncResult): [boolean, boolean];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.CallWaitingQuery">CallWaitingQuery()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_voice_call_call_waiting_query() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_call_waiting_query_sync(cancellable?: Gio.Cancellable | null): [boolean, boolean];
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.CallWaitingSetup">CallWaitingSetup()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_call_waiting_setup_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_call_waiting_setup_sync() for the synchronous, blocking version of this method.
             * @param arg_enable Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_call_waiting_setup(arg_enable: boolean, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.CallWaitingSetup">CallWaitingSetup()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_call_waiting_setup_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_call_waiting_setup_sync() for the synchronous, blocking version of this method.
             * @param arg_enable Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_call_waiting_setup(
                arg_enable: boolean,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.CallWaitingSetup">CallWaitingSetup()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_call_waiting_setup_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_call_waiting_setup_sync() for the synchronous, blocking version of this method.
             * @param arg_enable Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_call_waiting_setup(
                arg_enable: boolean,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_voice_call_call_waiting_setup().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_voice_call_call_waiting_setup().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_call_waiting_setup_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.CallWaitingSetup">CallWaitingSetup()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_voice_call_call_waiting_setup() for the asynchronous version of this method.
             * @param arg_enable Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_call_waiting_setup_sync(arg_enable: boolean, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.CreateCall">CreateCall()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_create_call_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_create_call_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_create_call(arg_properties: GLib.Variant, cancellable?: Gio.Cancellable | null): Promise<string>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.CreateCall">CreateCall()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_create_call_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_create_call_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_create_call(
                arg_properties: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.CreateCall">CreateCall()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_create_call_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_create_call_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_create_call(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<string> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_voice_call_create_call().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_voice_call_create_call().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_create_call_finish(res: Gio.AsyncResult): [boolean, string];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.CreateCall">CreateCall()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_voice_call_create_call() for the asynchronous version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_create_call_sync(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
            ): [boolean, string];
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.DeleteCall">DeleteCall()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_delete_call_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_delete_call_sync() for the synchronous, blocking version of this method.
             * @param arg_path Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_delete_call(arg_path: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.DeleteCall">DeleteCall()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_delete_call_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_delete_call_sync() for the synchronous, blocking version of this method.
             * @param arg_path Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_delete_call(
                arg_path: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.DeleteCall">DeleteCall()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_delete_call_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_delete_call_sync() for the synchronous, blocking version of this method.
             * @param arg_path Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_delete_call(
                arg_path: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_voice_call_delete_call().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_voice_call_delete_call().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_delete_call_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.DeleteCall">DeleteCall()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_voice_call_delete_call() for the asynchronous version of this method.
             * @param arg_path Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_delete_call_sync(arg_path: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.HangupAll">HangupAll()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_hangup_all_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_hangup_all_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_hangup_all(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.HangupAll">HangupAll()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_hangup_all_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_hangup_all_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_hangup_all(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.HangupAll">HangupAll()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_hangup_all_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_hangup_all_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_hangup_all(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_voice_call_hangup_all().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_voice_call_hangup_all().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_hangup_all_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.HangupAll">HangupAll()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_voice_call_hangup_all() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_hangup_all_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.HangupAndAccept">HangupAndAccept()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_hangup_and_accept_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_hangup_and_accept_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_hangup_and_accept(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.HangupAndAccept">HangupAndAccept()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_hangup_and_accept_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_hangup_and_accept_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_hangup_and_accept(
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.HangupAndAccept">HangupAndAccept()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_hangup_and_accept_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_hangup_and_accept_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_hangup_and_accept(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_voice_call_hangup_and_accept().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_voice_call_hangup_and_accept().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_hangup_and_accept_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.HangupAndAccept">HangupAndAccept()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_voice_call_hangup_and_accept() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_hangup_and_accept_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.HoldAndAccept">HoldAndAccept()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_hold_and_accept_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_hold_and_accept_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_hold_and_accept(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.HoldAndAccept">HoldAndAccept()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_hold_and_accept_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_hold_and_accept_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_hold_and_accept(
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.HoldAndAccept">HoldAndAccept()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_hold_and_accept_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_hold_and_accept_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_hold_and_accept(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_voice_call_hold_and_accept().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_voice_call_hold_and_accept().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_hold_and_accept_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.HoldAndAccept">HoldAndAccept()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_voice_call_hold_and_accept() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_hold_and_accept_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.ListCalls">ListCalls()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_list_calls_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_list_calls_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_list_calls(cancellable?: Gio.Cancellable | null): Promise<string[] | null>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.ListCalls">ListCalls()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_list_calls_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_list_calls_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_list_calls(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.ListCalls">ListCalls()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_list_calls_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_list_calls_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_list_calls(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<string[] | null> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_voice_call_list_calls().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_voice_call_list_calls().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_list_calls_finish(res: Gio.AsyncResult): [boolean, string[] | null];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.ListCalls">ListCalls()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_voice_call_list_calls() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_list_calls_sync(cancellable?: Gio.Cancellable | null): [boolean, string[] | null];
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.Transfer">Transfer()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_transfer_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_transfer_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_transfer(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.Transfer">Transfer()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_transfer_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_transfer_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_transfer(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.Transfer">Transfer()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_transfer_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_transfer_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_transfer(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_voice_call_transfer().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_voice_call_transfer().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_transfer_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.Transfer">Transfer()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_voice_call_transfer() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_transfer_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.CallWaitingQuery">CallWaitingQuery()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param status Parameter to return.
             */
            complete_call_waiting_query(invocation: Gio.DBusMethodInvocation, status: boolean): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.CallWaitingSetup">CallWaitingSetup()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_call_waiting_setup(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.CreateCall">CreateCall()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param path Parameter to return.
             */
            complete_create_call(invocation: Gio.DBusMethodInvocation, path: string): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.DeleteCall">DeleteCall()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_delete_call(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.HangupAll">HangupAll()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_hangup_all(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.HangupAndAccept">HangupAndAccept()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_hangup_and_accept(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.HoldAndAccept">HoldAndAccept()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_hold_and_accept(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.ListCalls">ListCalls()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param result Parameter to return.
             */
            complete_list_calls(invocation: Gio.DBusMethodInvocation, result: string): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.Transfer">Transfer()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_transfer(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Emits the <link linkend="gdbus-signal-org-freedesktop-ModemManager1-Modem-Voice.CallAdded">"CallAdded"</link> D-Bus signal.
             * @param arg_path Argument to pass with the signal.
             */
            emit_call_added(arg_path: string): void;
            /**
             * Emits the <link linkend="gdbus-signal-org-freedesktop-ModemManager1-Modem-Voice.CallDeleted">"CallDeleted"</link> D-Bus signal.
             * @param arg_path Argument to pass with the signal.
             */
            emit_call_deleted(arg_path: string): void;
            vfunc_call_added(arg_path: string): void;
            vfunc_call_deleted(arg_path: string): void;
            vfunc_handle_call_waiting_query(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_call_waiting_setup(invocation: Gio.DBusMethodInvocation, arg_enable: boolean): boolean;
            vfunc_handle_create_call(invocation: Gio.DBusMethodInvocation, arg_properties: GLib.Variant): boolean;
            vfunc_handle_delete_call(invocation: Gio.DBusMethodInvocation, arg_path: string): boolean;
            vfunc_handle_hangup_all(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_hangup_and_accept(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_hold_and_accept(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_list_calls(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_transfer(invocation: Gio.DBusMethodInvocation): boolean;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace GdbusModemVoiceSkeleton {
            // Constructor properties interface

            interface ConstructorProps
                extends Gio.DBusInterfaceSkeleton.ConstructorProps,
                    Gio.DBusInterface.ConstructorProps,
                    GdbusModemVoice.ConstructorProps {}
        }

        /**
         * The #MmGdbusModemVoiceSkeleton structure contains only private data and should only be accessed using the provided API.
         */
        class GdbusModemVoiceSkeleton extends Gio.DBusInterfaceSkeleton implements Gio.DBusInterface, GdbusModemVoice {
            static $gtype: GObject.GType<GdbusModemVoiceSkeleton>;

            // Constructors

            constructor(properties?: Partial<GdbusModemVoiceSkeleton.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static ['new'](): GdbusModemVoiceSkeleton;

            // Inherited properties
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Voice.Calls">"Calls"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get calls(): string[];
            set calls(val: string[]);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Voice.EmergencyOnly">"EmergencyOnly"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get emergency_only(): boolean;
            set emergency_only(val: boolean);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Voice.EmergencyOnly">"EmergencyOnly"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get emergencyOnly(): boolean;
            set emergencyOnly(val: boolean);

            // Inherited methods
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             * @returns A #GDBusObject or %NULL. The returned reference should be freed with g_object_unref().
             */
            get_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             * @returns A #GDBusInterfaceInfo. Do not free.
             */
            get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            set_object(object?: Gio.DBusObject | null): void;
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             */
            vfunc_dup_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             */
            vfunc_get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            vfunc_set_object(object?: Gio.DBusObject | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.CallWaitingQuery">CallWaitingQuery()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_call_waiting_query_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_call_waiting_query_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_call_waiting_query(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.CallWaitingQuery">CallWaitingQuery()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_call_waiting_query_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_call_waiting_query_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_call_waiting_query(
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.CallWaitingQuery">CallWaitingQuery()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_call_waiting_query_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_call_waiting_query_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_call_waiting_query(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_voice_call_call_waiting_query().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_voice_call_call_waiting_query().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_call_waiting_query_finish(res: Gio.AsyncResult): [boolean, boolean];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.CallWaitingQuery">CallWaitingQuery()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_voice_call_call_waiting_query() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_call_waiting_query_sync(cancellable?: Gio.Cancellable | null): [boolean, boolean];
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.CallWaitingSetup">CallWaitingSetup()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_call_waiting_setup_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_call_waiting_setup_sync() for the synchronous, blocking version of this method.
             * @param arg_enable Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_call_waiting_setup(arg_enable: boolean, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.CallWaitingSetup">CallWaitingSetup()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_call_waiting_setup_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_call_waiting_setup_sync() for the synchronous, blocking version of this method.
             * @param arg_enable Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_call_waiting_setup(
                arg_enable: boolean,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.CallWaitingSetup">CallWaitingSetup()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_call_waiting_setup_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_call_waiting_setup_sync() for the synchronous, blocking version of this method.
             * @param arg_enable Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_call_waiting_setup(
                arg_enable: boolean,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_voice_call_call_waiting_setup().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_voice_call_call_waiting_setup().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_call_waiting_setup_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.CallWaitingSetup">CallWaitingSetup()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_voice_call_call_waiting_setup() for the asynchronous version of this method.
             * @param arg_enable Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_call_waiting_setup_sync(arg_enable: boolean, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.CreateCall">CreateCall()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_create_call_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_create_call_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_create_call(arg_properties: GLib.Variant, cancellable?: Gio.Cancellable | null): Promise<string>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.CreateCall">CreateCall()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_create_call_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_create_call_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_create_call(
                arg_properties: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.CreateCall">CreateCall()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_create_call_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_create_call_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_create_call(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<string> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_voice_call_create_call().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_voice_call_create_call().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_create_call_finish(res: Gio.AsyncResult): [boolean, string];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.CreateCall">CreateCall()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_voice_call_create_call() for the asynchronous version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_create_call_sync(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
            ): [boolean, string];
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.DeleteCall">DeleteCall()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_delete_call_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_delete_call_sync() for the synchronous, blocking version of this method.
             * @param arg_path Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_delete_call(arg_path: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.DeleteCall">DeleteCall()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_delete_call_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_delete_call_sync() for the synchronous, blocking version of this method.
             * @param arg_path Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_delete_call(
                arg_path: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.DeleteCall">DeleteCall()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_delete_call_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_delete_call_sync() for the synchronous, blocking version of this method.
             * @param arg_path Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_delete_call(
                arg_path: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_voice_call_delete_call().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_voice_call_delete_call().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_delete_call_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.DeleteCall">DeleteCall()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_voice_call_delete_call() for the asynchronous version of this method.
             * @param arg_path Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_delete_call_sync(arg_path: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.HangupAll">HangupAll()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_hangup_all_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_hangup_all_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_hangup_all(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.HangupAll">HangupAll()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_hangup_all_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_hangup_all_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_hangup_all(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.HangupAll">HangupAll()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_hangup_all_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_hangup_all_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_hangup_all(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_voice_call_hangup_all().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_voice_call_hangup_all().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_hangup_all_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.HangupAll">HangupAll()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_voice_call_hangup_all() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_hangup_all_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.HangupAndAccept">HangupAndAccept()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_hangup_and_accept_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_hangup_and_accept_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_hangup_and_accept(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.HangupAndAccept">HangupAndAccept()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_hangup_and_accept_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_hangup_and_accept_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_hangup_and_accept(
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.HangupAndAccept">HangupAndAccept()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_hangup_and_accept_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_hangup_and_accept_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_hangup_and_accept(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_voice_call_hangup_and_accept().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_voice_call_hangup_and_accept().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_hangup_and_accept_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.HangupAndAccept">HangupAndAccept()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_voice_call_hangup_and_accept() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_hangup_and_accept_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.HoldAndAccept">HoldAndAccept()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_hold_and_accept_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_hold_and_accept_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_hold_and_accept(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.HoldAndAccept">HoldAndAccept()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_hold_and_accept_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_hold_and_accept_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_hold_and_accept(
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.HoldAndAccept">HoldAndAccept()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_hold_and_accept_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_hold_and_accept_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_hold_and_accept(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_voice_call_hold_and_accept().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_voice_call_hold_and_accept().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_hold_and_accept_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.HoldAndAccept">HoldAndAccept()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_voice_call_hold_and_accept() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_hold_and_accept_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.ListCalls">ListCalls()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_list_calls_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_list_calls_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_list_calls(cancellable?: Gio.Cancellable | null): Promise<string[] | null>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.ListCalls">ListCalls()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_list_calls_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_list_calls_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_list_calls(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.ListCalls">ListCalls()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_list_calls_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_list_calls_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_list_calls(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<string[] | null> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_voice_call_list_calls().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_voice_call_list_calls().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_list_calls_finish(res: Gio.AsyncResult): [boolean, string[] | null];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.ListCalls">ListCalls()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_voice_call_list_calls() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_list_calls_sync(cancellable?: Gio.Cancellable | null): [boolean, string[] | null];
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.Transfer">Transfer()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_transfer_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_transfer_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_transfer(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.Transfer">Transfer()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_transfer_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_transfer_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_transfer(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.Transfer">Transfer()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_transfer_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_transfer_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_transfer(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_voice_call_transfer().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_voice_call_transfer().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_transfer_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.Transfer">Transfer()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_voice_call_transfer() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_transfer_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.CallWaitingQuery">CallWaitingQuery()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param status Parameter to return.
             */
            complete_call_waiting_query(invocation: Gio.DBusMethodInvocation, status: boolean): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.CallWaitingSetup">CallWaitingSetup()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_call_waiting_setup(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.CreateCall">CreateCall()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param path Parameter to return.
             */
            complete_create_call(invocation: Gio.DBusMethodInvocation, path: string): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.DeleteCall">DeleteCall()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_delete_call(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.HangupAll">HangupAll()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_hangup_all(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.HangupAndAccept">HangupAndAccept()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_hangup_and_accept(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.HoldAndAccept">HoldAndAccept()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_hold_and_accept(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.ListCalls">ListCalls()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param result Parameter to return.
             */
            complete_list_calls(invocation: Gio.DBusMethodInvocation, result: string): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.Transfer">Transfer()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_transfer(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Emits the <link linkend="gdbus-signal-org-freedesktop-ModemManager1-Modem-Voice.CallAdded">"CallAdded"</link> D-Bus signal.
             * @param arg_path Argument to pass with the signal.
             */
            emit_call_added(arg_path: string): void;
            /**
             * Emits the <link linkend="gdbus-signal-org-freedesktop-ModemManager1-Modem-Voice.CallDeleted">"CallDeleted"</link> D-Bus signal.
             * @param arg_path Argument to pass with the signal.
             */
            emit_call_deleted(arg_path: string): void;
            vfunc_call_added(arg_path: string): void;
            vfunc_call_deleted(arg_path: string): void;
            vfunc_handle_call_waiting_query(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_call_waiting_setup(invocation: Gio.DBusMethodInvocation, arg_enable: boolean): boolean;
            vfunc_handle_create_call(invocation: Gio.DBusMethodInvocation, arg_properties: GLib.Variant): boolean;
            vfunc_handle_delete_call(invocation: Gio.DBusMethodInvocation, arg_path: string): boolean;
            vfunc_handle_hangup_all(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_hangup_and_accept(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_hold_and_accept(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_list_calls(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_transfer(invocation: Gio.DBusMethodInvocation): boolean;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace GdbusObjectManagerClient {
            // Constructor properties interface

            interface ConstructorProps
                extends Gio.DBusObjectManagerClient.ConstructorProps,
                    Gio.AsyncInitable.ConstructorProps,
                    Gio.DBusObjectManager.ConstructorProps,
                    Gio.Initable.ConstructorProps {}
        }

        /**
         * The #MmGdbusObjectManagerClient structure contains only private data and should only be accessed using the provided API.
         */
        class GdbusObjectManagerClient
            extends Gio.DBusObjectManagerClient
            implements Gio.AsyncInitable<GdbusObjectManagerClient>, Gio.DBusObjectManager, Gio.Initable
        {
            static $gtype: GObject.GType<GdbusObjectManagerClient>;

            // Constructors

            constructor(properties?: Partial<GdbusObjectManagerClient.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static new_finish(res: Gio.AsyncResult): GdbusObjectManagerClient;
            // Conflicted with Gio.AsyncInitable.new_finish

            static new_finish(...args: never[]): any;

            static new_for_bus_finish(res: Gio.AsyncResult): GdbusObjectManagerClient;

            static new_for_bus_sync(
                bus_type: Gio.BusType,
                flags: Gio.DBusObjectManagerClientFlags,
                name: string,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
            ): GdbusObjectManagerClient;
            // Conflicted with Gio.DBusObjectManagerClient.new_for_bus_sync

            static new_for_bus_sync(...args: never[]): any;

            static new_sync(
                connection: Gio.DBusConnection,
                flags: Gio.DBusObjectManagerClientFlags,
                name: string | null,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
            ): GdbusObjectManagerClient;
            // Conflicted with Gio.DBusObjectManagerClient.new_sync

            static new_sync(...args: never[]): any;

            // Static methods

            /**
             * A #GDBusProxyTypeFunc that maps `interface_name` to the generated #GDBusObjectProxy derived and #GDBusProxy derived types.
             * @param manager A #GDBusObjectManagerClient.
             * @param object_path The object path of the remote object (unused).
             * @param interface_name Interface name of the remote object or %NULL to get the object proxy #GType.
             * @param user_data User data (unused).
             */
            static get_proxy_type(
                manager: Gio.DBusObjectManagerClient,
                object_path: string,
                interface_name?: string | null,
                user_data?: any | null,
            ): GObject.GType;
            /**
             * Asynchronously creates #GDBusObjectManagerClient using mm_gdbus_object_manager_client_get_proxy_type() as the #GDBusProxyTypeFunc. See g_dbus_object_manager_client_new() for more details.
             *
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_object_manager_client_new_finish() to get the result of the operation.
             *
             * See mm_gdbus_object_manager_client_new_sync() for the synchronous, blocking version of this constructor.
             * @param connection A #GDBusConnection.
             * @param flags Flags from the #GDBusObjectManagerClientFlags enumeration.
             * @param name A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
             * @param object_path An object path.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied.
             */
            static ['new'](
                connection: Gio.DBusConnection,
                flags: Gio.DBusObjectManagerClientFlags,
                name: string | null,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<GdbusObjectManagerClient> | null,
            ): void;
            // Conflicted with Gio.DBusObjectManagerClient.new
            static ['new'](...args: never[]): any;
            /**
             * Like mm_gdbus_object_manager_client_new() but takes a #GBusType instead of a #GDBusConnection.
             *
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_object_manager_client_new_for_bus_finish() to get the result of the operation.
             *
             * See mm_gdbus_object_manager_client_new_for_bus_sync() for the synchronous, blocking version of this constructor.
             * @param bus_type A #GBusType.
             * @param flags Flags from the #GDBusObjectManagerClientFlags enumeration.
             * @param name A bus name (well-known or unique).
             * @param object_path An object path.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied.
             */
            static new_for_bus(
                bus_type: Gio.BusType,
                flags: Gio.DBusObjectManagerClientFlags,
                name: string,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<GdbusObjectManagerClient> | null,
            ): void;
            // Conflicted with Gio.DBusObjectManagerClient.new_for_bus
            static new_for_bus(...args: never[]): any;

            // Inherited methods
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            init_async(io_priority: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             * @returns %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present.
             */
            init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Finishes the async construction for the various g_async_initable_new
             * calls, returning the created object or %NULL on error.
             * @param res the #GAsyncResult from the callback
             * @returns a newly created #GObject,      or %NULL on error. Free with g_object_unref().
             */
            new_finish(res: Gio.AsyncResult): GdbusObjectManagerClient;
            // Conflicted with Gio.DBusObjectManagerClient.new_finish
            new_finish(...args: never[]): any;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            vfunc_init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             */
            vfunc_init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Gets the interface proxy for `interface_name` at `object_path,` if
             * any.
             * @param object_path Object path to look up.
             * @param interface_name D-Bus interface name to look up.
             * @returns A #GDBusInterface instance or %NULL. Free   with g_object_unref().
             */
            get_interface(object_path: string, interface_name: string): Gio.DBusInterface | null;
            /**
             * Gets the #GDBusObject at `object_path,` if any.
             * @param object_path Object path to look up.
             * @returns A #GDBusObject or %NULL. Free with   g_object_unref().
             */
            get_object(object_path: string): Gio.DBusObject | null;
            /**
             * Gets the object path that `manager` is for.
             * @returns A string owned by @manager. Do not free.
             */
            get_object_path(): string;
            /**
             * Gets all #GDBusObject objects known to `manager`.
             * @returns A list of   #GDBusObject objects. The returned list should be freed with   g_list_free() after each element has been freed with   g_object_unref().
             */
            get_objects(): Gio.DBusObject[];
            /**
             * Gets the interface proxy for `interface_name` at `object_path,` if
             * any.
             * @param object_path Object path to look up.
             * @param interface_name D-Bus interface name to look up.
             */
            vfunc_get_interface(object_path: string, interface_name: string): Gio.DBusInterface | null;
            /**
             * Gets the #GDBusObject at `object_path,` if any.
             * @param object_path Object path to look up.
             */
            vfunc_get_object(object_path: string): Gio.DBusObject | null;
            /**
             * Gets the object path that `manager` is for.
             */
            vfunc_get_object_path(): string;
            /**
             * Gets all #GDBusObject objects known to `manager`.
             */
            vfunc_get_objects(): Gio.DBusObject[];
            /**
             * Signal handler for the #GDBusObjectManager::interface-added signal.
             * @param object
             * @param interface_
             */
            vfunc_interface_added(object: Gio.DBusObject, interface_: Gio.DBusInterface): void;
            /**
             * Signal handler for the #GDBusObjectManager::interface-removed signal.
             * @param object
             * @param interface_
             */
            vfunc_interface_removed(object: Gio.DBusObject, interface_: Gio.DBusInterface): void;
            /**
             * Signal handler for the #GDBusObjectManager::object-added signal.
             * @param object
             */
            vfunc_object_added(object: Gio.DBusObject): void;
            /**
             * Signal handler for the #GDBusObjectManager::object-removed signal.
             * @param object
             */
            vfunc_object_removed(object: Gio.DBusObject): void;
            /**
             * Initializes the object implementing the interface.
             *
             * This method is intended for language bindings. If writing in C,
             * g_initable_new() should typically be used instead.
             *
             * The object must be initialized before any real use after initial
             * construction, either with this function or g_async_initable_init_async().
             *
             * Implementations may also support cancellation. If `cancellable` is not %NULL,
             * then initialization can be cancelled by triggering the cancellable object
             * from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
             * the object doesn't support cancellable initialization the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * If the object is not initialized, or initialization returns with an
             * error, then all operations on the object except g_object_ref() and
             * g_object_unref() are considered to be invalid, and have undefined
             * behaviour. See the [description][iface`Gio`.Initable#description] for more details.
             *
             * Callers should not assume that a class which implements #GInitable can be
             * initialized multiple times, unless the class explicitly documents itself as
             * supporting this. Generally, a class’ implementation of init() can assume
             * (and assert) that it will only be called once. Previously, this documentation
             * recommended all #GInitable implementations should be idempotent; that
             * recommendation was relaxed in GLib 2.54.
             *
             * If a class explicitly supports being initialized multiple times, it is
             * recommended that the method is idempotent: multiple calls with the same
             * arguments should return the same results. Only the first call initializes
             * the object; further calls return the result of the first call.
             *
             * One reason why a class might need to support idempotent initialization is if
             * it is designed to be used via the singleton pattern, with a
             * #GObjectClass.constructor that sometimes returns an existing instance.
             * In this pattern, a caller would expect to be able to call g_initable_init()
             * on the result of g_object_new(), regardless of whether it is in fact a new
             * instance.
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @returns %TRUE if successful. If an error has occurred, this function will     return %FALSE and set @error appropriately if present.
             */
            init(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Initializes the object implementing the interface.
             *
             * This method is intended for language bindings. If writing in C,
             * g_initable_new() should typically be used instead.
             *
             * The object must be initialized before any real use after initial
             * construction, either with this function or g_async_initable_init_async().
             *
             * Implementations may also support cancellation. If `cancellable` is not %NULL,
             * then initialization can be cancelled by triggering the cancellable object
             * from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
             * the object doesn't support cancellable initialization the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * If the object is not initialized, or initialization returns with an
             * error, then all operations on the object except g_object_ref() and
             * g_object_unref() are considered to be invalid, and have undefined
             * behaviour. See the [description][iface`Gio`.Initable#description] for more details.
             *
             * Callers should not assume that a class which implements #GInitable can be
             * initialized multiple times, unless the class explicitly documents itself as
             * supporting this. Generally, a class’ implementation of init() can assume
             * (and assert) that it will only be called once. Previously, this documentation
             * recommended all #GInitable implementations should be idempotent; that
             * recommendation was relaxed in GLib 2.54.
             *
             * If a class explicitly supports being initialized multiple times, it is
             * recommended that the method is idempotent: multiple calls with the same
             * arguments should return the same results. Only the first call initializes
             * the object; further calls return the result of the first call.
             *
             * One reason why a class might need to support idempotent initialization is if
             * it is designed to be used via the singleton pattern, with a
             * #GObjectClass.constructor that sometimes returns an existing instance.
             * In this pattern, a caller would expect to be able to call g_initable_init()
             * on the result of g_object_new(), regardless of whether it is in fact a new
             * instance.
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            vfunc_init(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace GdbusObjectProxy {
            // Constructor properties interface

            interface ConstructorProps
                extends Gio.DBusObjectProxy.ConstructorProps,
                    Gio.DBusObject.ConstructorProps,
                    GdbusObject.ConstructorProps {}
        }

        /**
         * The #MmGdbusObjectProxy structure contains only private data and should only be accessed using the provided API.
         */
        class GdbusObjectProxy extends Gio.DBusObjectProxy implements Gio.DBusObject, GdbusObject {
            static $gtype: GObject.GType<GdbusObjectProxy>;

            // Constructors

            constructor(properties?: Partial<GdbusObjectProxy.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static ['new'](connection: Gio.DBusConnection, object_path: string): GdbusObjectProxy;

            // Inherited properties
            /**
             * The #MmGdbusModem instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem.top_of_page">org.freedesktop.ModemManager1.Modem</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem(): GdbusModem;
            set modem(val: GdbusModem);
            /**
             * The #MmGdbusModemCdma instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-ModemCdma.top_of_page">org.freedesktop.ModemManager1.Modem.ModemCdma</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem_cdma(): GdbusModemCdma;
            set modem_cdma(val: GdbusModemCdma);
            /**
             * The #MmGdbusModemCdma instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-ModemCdma.top_of_page">org.freedesktop.ModemManager1.Modem.ModemCdma</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modemCdma(): GdbusModemCdma;
            set modemCdma(val: GdbusModemCdma);
            /**
             * The #MmGdbusModemFirmware instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Firmware.top_of_page">org.freedesktop.ModemManager1.Modem.Firmware</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem_firmware(): GdbusModemFirmware;
            set modem_firmware(val: GdbusModemFirmware);
            /**
             * The #MmGdbusModemFirmware instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Firmware.top_of_page">org.freedesktop.ModemManager1.Modem.Firmware</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modemFirmware(): GdbusModemFirmware;
            set modemFirmware(val: GdbusModemFirmware);
            /**
             * The #MmGdbusModemLocation instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Location.top_of_page">org.freedesktop.ModemManager1.Modem.Location</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem_location(): GdbusModemLocation;
            set modem_location(val: GdbusModemLocation);
            /**
             * The #MmGdbusModemLocation instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Location.top_of_page">org.freedesktop.ModemManager1.Modem.Location</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modemLocation(): GdbusModemLocation;
            set modemLocation(val: GdbusModemLocation);
            /**
             * The #MmGdbusModemMessaging instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Messaging.top_of_page">org.freedesktop.ModemManager1.Modem.Messaging</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem_messaging(): GdbusModemMessaging;
            set modem_messaging(val: GdbusModemMessaging);
            /**
             * The #MmGdbusModemMessaging instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Messaging.top_of_page">org.freedesktop.ModemManager1.Modem.Messaging</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modemMessaging(): GdbusModemMessaging;
            set modemMessaging(val: GdbusModemMessaging);
            /**
             * The #MmGdbusModemOma instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Oma.top_of_page">org.freedesktop.ModemManager1.Modem.Oma</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem_oma(): GdbusModemOma;
            set modem_oma(val: GdbusModemOma);
            /**
             * The #MmGdbusModemOma instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Oma.top_of_page">org.freedesktop.ModemManager1.Modem.Oma</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modemOma(): GdbusModemOma;
            set modemOma(val: GdbusModemOma);
            /**
             * The #MmGdbusModemSar instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Sar.top_of_page">org.freedesktop.ModemManager1.Modem.Sar</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem_sar(): GdbusModemSar;
            set modem_sar(val: GdbusModemSar);
            /**
             * The #MmGdbusModemSar instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Sar.top_of_page">org.freedesktop.ModemManager1.Modem.Sar</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modemSar(): GdbusModemSar;
            set modemSar(val: GdbusModemSar);
            /**
             * The #MmGdbusModemSignal instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Signal.top_of_page">org.freedesktop.ModemManager1.Modem.Signal</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem_signal(): GdbusModemSignal;
            set modem_signal(val: GdbusModemSignal);
            /**
             * The #MmGdbusModemSignal instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Signal.top_of_page">org.freedesktop.ModemManager1.Modem.Signal</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modemSignal(): GdbusModemSignal;
            set modemSignal(val: GdbusModemSignal);
            /**
             * The #MmGdbusModemSimple instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Simple.top_of_page">org.freedesktop.ModemManager1.Modem.Simple</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem_simple(): GdbusModemSimple;
            set modem_simple(val: GdbusModemSimple);
            /**
             * The #MmGdbusModemSimple instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Simple.top_of_page">org.freedesktop.ModemManager1.Modem.Simple</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modemSimple(): GdbusModemSimple;
            set modemSimple(val: GdbusModemSimple);
            /**
             * The #MmGdbusModemTime instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Time.top_of_page">org.freedesktop.ModemManager1.Modem.Time</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem_time(): GdbusModemTime;
            set modem_time(val: GdbusModemTime);
            /**
             * The #MmGdbusModemTime instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Time.top_of_page">org.freedesktop.ModemManager1.Modem.Time</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modemTime(): GdbusModemTime;
            set modemTime(val: GdbusModemTime);
            /**
             * The #MmGdbusModemVoice instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Voice.top_of_page">org.freedesktop.ModemManager1.Modem.Voice</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem_voice(): GdbusModemVoice;
            set modem_voice(val: GdbusModemVoice);
            /**
             * The #MmGdbusModemVoice instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Voice.top_of_page">org.freedesktop.ModemManager1.Modem.Voice</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modemVoice(): GdbusModemVoice;
            set modemVoice(val: GdbusModemVoice);
            /**
             * The #MmGdbusModem3gpp instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Modem3gpp.top_of_page">org.freedesktop.ModemManager1.Modem.Modem3gpp</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem3gpp(): GdbusModem3gpp;
            set modem3gpp(val: GdbusModem3gpp);
            /**
             * The #MmGdbusModem3gppProfileManager instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.top_of_page">org.freedesktop.ModemManager1.Modem.Modem3gpp.ProfileManager</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem3gpp_profile_manager(): GdbusModem3gppProfileManager;
            set modem3gpp_profile_manager(val: GdbusModem3gppProfileManager);
            /**
             * The #MmGdbusModem3gppProfileManager instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.top_of_page">org.freedesktop.ModemManager1.Modem.Modem3gpp.ProfileManager</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem3gppProfileManager(): GdbusModem3gppProfileManager;
            set modem3gppProfileManager(val: GdbusModem3gppProfileManager);
            /**
             * The #MmGdbusModem3gppUssd instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.top_of_page">org.freedesktop.ModemManager1.Modem.Modem3gpp.Ussd</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem3gpp_ussd(): GdbusModem3gppUssd;
            set modem3gpp_ussd(val: GdbusModem3gppUssd);
            /**
             * The #MmGdbusModem3gppUssd instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.top_of_page">org.freedesktop.ModemManager1.Modem.Modem3gpp.Ussd</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem3gppUssd(): GdbusModem3gppUssd;
            set modem3gppUssd(val: GdbusModem3gppUssd);

            // Inherited methods
            /**
             * Gets the D-Bus interface with name `interface_name` associated with
             * `object,` if any.
             * @param interface_name A D-Bus interface name.
             * @returns %NULL if not found, otherwise a   #GDBusInterface that must be freed with g_object_unref().
             */
            get_interface(interface_name: string): Gio.DBusInterface | null;
            /**
             * Gets the D-Bus interfaces associated with `object`.
             * @returns A list of #GDBusInterface instances.   The returned list must be freed by g_list_free() after each element has been freed   with g_object_unref().
             */
            get_interfaces(): Gio.DBusInterface[];
            /**
             * Gets the object path for `object`.
             * @returns A string owned by @object. Do not free.
             */
            get_object_path(): string;
            /**
             * Gets the D-Bus interface with name `interface_name` associated with
             * `object,` if any.
             * @param interface_name A D-Bus interface name.
             */
            vfunc_get_interface(interface_name: string): Gio.DBusInterface | null;
            /**
             * Gets the D-Bus interfaces associated with `object`.
             */
            vfunc_get_interfaces(): Gio.DBusInterface[];
            /**
             * Gets the object path for `object`.
             */
            vfunc_get_object_path(): string;
            /**
             * Signal handler for the #GDBusObject::interface-added signal.
             * @param interface_
             */
            vfunc_interface_added(interface_: Gio.DBusInterface): void;
            /**
             * Signal handler for the #GDBusObject::interface-removed signal.
             * @param interface_
             */
            vfunc_interface_removed(interface_: Gio.DBusInterface): void;
            /**
             * Gets the #MmGdbusModem instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem.top_of_page">org.freedesktop.ModemManager1.Modem</link> on `object,` if any.
             * @returns A #MmGdbusModem that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
             */
            get_modem(): GdbusModem | null;
            /**
             * Gets the #MmGdbusModem3gpp instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Modem3gpp.top_of_page">org.freedesktop.ModemManager1.Modem.Modem3gpp</link> on `object,` if any.
             * @returns A #MmGdbusModem3gpp that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
             */
            get_modem3gpp(): GdbusModem3gpp | null;
            /**
             * Gets the #MmGdbusModem3gppProfileManager instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.top_of_page">org.freedesktop.ModemManager1.Modem.Modem3gpp.ProfileManager</link> on `object,` if any.
             * @returns A #MmGdbusModem3gppProfileManager that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
             */
            get_modem3gpp_profile_manager(): GdbusModem3gppProfileManager | null;
            /**
             * Gets the #MmGdbusModem3gppUssd instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.top_of_page">org.freedesktop.ModemManager1.Modem.Modem3gpp.Ussd</link> on `object,` if any.
             * @returns A #MmGdbusModem3gppUssd that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
             */
            get_modem3gpp_ussd(): GdbusModem3gppUssd | null;
            /**
             * Gets the #MmGdbusModemCdma instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-ModemCdma.top_of_page">org.freedesktop.ModemManager1.Modem.ModemCdma</link> on `object,` if any.
             * @returns A #MmGdbusModemCdma that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
             */
            get_modem_cdma(): GdbusModemCdma | null;
            /**
             * Gets the #MmGdbusModemFirmware instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Firmware.top_of_page">org.freedesktop.ModemManager1.Modem.Firmware</link> on `object,` if any.
             * @returns A #MmGdbusModemFirmware that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
             */
            get_modem_firmware(): GdbusModemFirmware | null;
            /**
             * Gets the #MmGdbusModemLocation instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Location.top_of_page">org.freedesktop.ModemManager1.Modem.Location</link> on `object,` if any.
             * @returns A #MmGdbusModemLocation that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
             */
            get_modem_location(): GdbusModemLocation | null;
            /**
             * Gets the #MmGdbusModemMessaging instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Messaging.top_of_page">org.freedesktop.ModemManager1.Modem.Messaging</link> on `object,` if any.
             * @returns A #MmGdbusModemMessaging that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
             */
            get_modem_messaging(): GdbusModemMessaging | null;
            /**
             * Gets the #MmGdbusModemOma instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Oma.top_of_page">org.freedesktop.ModemManager1.Modem.Oma</link> on `object,` if any.
             * @returns A #MmGdbusModemOma that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
             */
            get_modem_oma(): GdbusModemOma | null;
            /**
             * Gets the #MmGdbusModemSar instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Sar.top_of_page">org.freedesktop.ModemManager1.Modem.Sar</link> on `object,` if any.
             * @returns A #MmGdbusModemSar that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
             */
            get_modem_sar(): GdbusModemSar | null;
            /**
             * Gets the #MmGdbusModemSignal instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Signal.top_of_page">org.freedesktop.ModemManager1.Modem.Signal</link> on `object,` if any.
             * @returns A #MmGdbusModemSignal that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
             */
            get_modem_signal(): GdbusModemSignal | null;
            /**
             * Gets the #MmGdbusModemSimple instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Simple.top_of_page">org.freedesktop.ModemManager1.Modem.Simple</link> on `object,` if any.
             * @returns A #MmGdbusModemSimple that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
             */
            get_modem_simple(): GdbusModemSimple | null;
            /**
             * Gets the #MmGdbusModemTime instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Time.top_of_page">org.freedesktop.ModemManager1.Modem.Time</link> on `object,` if any.
             * @returns A #MmGdbusModemTime that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
             */
            get_modem_time(): GdbusModemTime | null;
            /**
             * Gets the #MmGdbusModemVoice instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Voice.top_of_page">org.freedesktop.ModemManager1.Modem.Voice</link> on `object,` if any.
             * @returns A #MmGdbusModemVoice that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
             */
            get_modem_voice(): GdbusModemVoice | null;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace GdbusObjectSkeleton {
            // Constructor properties interface

            interface ConstructorProps
                extends Gio.DBusObjectSkeleton.ConstructorProps,
                    Gio.DBusObject.ConstructorProps,
                    GdbusObject.ConstructorProps {}
        }

        /**
         * The #MmGdbusObjectSkeleton structure contains only private data and should only be accessed using the provided API.
         */
        class GdbusObjectSkeleton extends Gio.DBusObjectSkeleton implements Gio.DBusObject, GdbusObject {
            static $gtype: GObject.GType<GdbusObjectSkeleton>;

            // Constructors

            constructor(properties?: Partial<GdbusObjectSkeleton.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static ['new'](object_path: string): GdbusObjectSkeleton;

            // Methods

            /**
             * Sets the #MmGdbusModem instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem.top_of_page">org.freedesktop.ModemManager1.Modem</link> on `object`.
             * @param interface_ A #MmGdbusModem or %NULL to clear the interface.
             */
            set_modem(interface_?: GdbusModem | null): void;
            /**
             * Sets the #MmGdbusModem3gpp instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Modem3gpp.top_of_page">org.freedesktop.ModemManager1.Modem.Modem3gpp</link> on `object`.
             * @param interface_ A #MmGdbusModem3gpp or %NULL to clear the interface.
             */
            set_modem3gpp(interface_?: GdbusModem3gpp | null): void;
            /**
             * Sets the #MmGdbusModem3gppProfileManager instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.top_of_page">org.freedesktop.ModemManager1.Modem.Modem3gpp.ProfileManager</link> on `object`.
             * @param interface_ A #MmGdbusModem3gppProfileManager or %NULL to clear the interface.
             */
            set_modem3gpp_profile_manager(interface_?: GdbusModem3gppProfileManager | null): void;
            /**
             * Sets the #MmGdbusModem3gppUssd instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.top_of_page">org.freedesktop.ModemManager1.Modem.Modem3gpp.Ussd</link> on `object`.
             * @param interface_ A #MmGdbusModem3gppUssd or %NULL to clear the interface.
             */
            set_modem3gpp_ussd(interface_?: GdbusModem3gppUssd | null): void;
            /**
             * Sets the #MmGdbusModemCdma instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-ModemCdma.top_of_page">org.freedesktop.ModemManager1.Modem.ModemCdma</link> on `object`.
             * @param interface_ A #MmGdbusModemCdma or %NULL to clear the interface.
             */
            set_modem_cdma(interface_?: GdbusModemCdma | null): void;
            /**
             * Sets the #MmGdbusModemFirmware instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Firmware.top_of_page">org.freedesktop.ModemManager1.Modem.Firmware</link> on `object`.
             * @param interface_ A #MmGdbusModemFirmware or %NULL to clear the interface.
             */
            set_modem_firmware(interface_?: GdbusModemFirmware | null): void;
            /**
             * Sets the #MmGdbusModemLocation instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Location.top_of_page">org.freedesktop.ModemManager1.Modem.Location</link> on `object`.
             * @param interface_ A #MmGdbusModemLocation or %NULL to clear the interface.
             */
            set_modem_location(interface_?: GdbusModemLocation | null): void;
            /**
             * Sets the #MmGdbusModemMessaging instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Messaging.top_of_page">org.freedesktop.ModemManager1.Modem.Messaging</link> on `object`.
             * @param interface_ A #MmGdbusModemMessaging or %NULL to clear the interface.
             */
            set_modem_messaging(interface_?: GdbusModemMessaging | null): void;
            /**
             * Sets the #MmGdbusModemOma instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Oma.top_of_page">org.freedesktop.ModemManager1.Modem.Oma</link> on `object`.
             * @param interface_ A #MmGdbusModemOma or %NULL to clear the interface.
             */
            set_modem_oma(interface_?: GdbusModemOma | null): void;
            /**
             * Sets the #MmGdbusModemSar instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Sar.top_of_page">org.freedesktop.ModemManager1.Modem.Sar</link> on `object`.
             * @param interface_ A #MmGdbusModemSar or %NULL to clear the interface.
             */
            set_modem_sar(interface_?: GdbusModemSar | null): void;
            /**
             * Sets the #MmGdbusModemSignal instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Signal.top_of_page">org.freedesktop.ModemManager1.Modem.Signal</link> on `object`.
             * @param interface_ A #MmGdbusModemSignal or %NULL to clear the interface.
             */
            set_modem_signal(interface_?: GdbusModemSignal | null): void;
            /**
             * Sets the #MmGdbusModemSimple instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Simple.top_of_page">org.freedesktop.ModemManager1.Modem.Simple</link> on `object`.
             * @param interface_ A #MmGdbusModemSimple or %NULL to clear the interface.
             */
            set_modem_simple(interface_?: GdbusModemSimple | null): void;
            /**
             * Sets the #MmGdbusModemTime instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Time.top_of_page">org.freedesktop.ModemManager1.Modem.Time</link> on `object`.
             * @param interface_ A #MmGdbusModemTime or %NULL to clear the interface.
             */
            set_modem_time(interface_?: GdbusModemTime | null): void;
            /**
             * Sets the #MmGdbusModemVoice instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Voice.top_of_page">org.freedesktop.ModemManager1.Modem.Voice</link> on `object`.
             * @param interface_ A #MmGdbusModemVoice or %NULL to clear the interface.
             */
            set_modem_voice(interface_?: GdbusModemVoice | null): void;

            // Inherited properties
            /**
             * The #MmGdbusModem instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem.top_of_page">org.freedesktop.ModemManager1.Modem</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem(): GdbusModem;
            set modem(val: GdbusModem);
            /**
             * The #MmGdbusModemCdma instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-ModemCdma.top_of_page">org.freedesktop.ModemManager1.Modem.ModemCdma</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem_cdma(): GdbusModemCdma;
            set modem_cdma(val: GdbusModemCdma);
            /**
             * The #MmGdbusModemCdma instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-ModemCdma.top_of_page">org.freedesktop.ModemManager1.Modem.ModemCdma</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modemCdma(): GdbusModemCdma;
            set modemCdma(val: GdbusModemCdma);
            /**
             * The #MmGdbusModemFirmware instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Firmware.top_of_page">org.freedesktop.ModemManager1.Modem.Firmware</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem_firmware(): GdbusModemFirmware;
            set modem_firmware(val: GdbusModemFirmware);
            /**
             * The #MmGdbusModemFirmware instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Firmware.top_of_page">org.freedesktop.ModemManager1.Modem.Firmware</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modemFirmware(): GdbusModemFirmware;
            set modemFirmware(val: GdbusModemFirmware);
            /**
             * The #MmGdbusModemLocation instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Location.top_of_page">org.freedesktop.ModemManager1.Modem.Location</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem_location(): GdbusModemLocation;
            set modem_location(val: GdbusModemLocation);
            /**
             * The #MmGdbusModemLocation instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Location.top_of_page">org.freedesktop.ModemManager1.Modem.Location</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modemLocation(): GdbusModemLocation;
            set modemLocation(val: GdbusModemLocation);
            /**
             * The #MmGdbusModemMessaging instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Messaging.top_of_page">org.freedesktop.ModemManager1.Modem.Messaging</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem_messaging(): GdbusModemMessaging;
            set modem_messaging(val: GdbusModemMessaging);
            /**
             * The #MmGdbusModemMessaging instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Messaging.top_of_page">org.freedesktop.ModemManager1.Modem.Messaging</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modemMessaging(): GdbusModemMessaging;
            set modemMessaging(val: GdbusModemMessaging);
            /**
             * The #MmGdbusModemOma instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Oma.top_of_page">org.freedesktop.ModemManager1.Modem.Oma</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem_oma(): GdbusModemOma;
            set modem_oma(val: GdbusModemOma);
            /**
             * The #MmGdbusModemOma instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Oma.top_of_page">org.freedesktop.ModemManager1.Modem.Oma</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modemOma(): GdbusModemOma;
            set modemOma(val: GdbusModemOma);
            /**
             * The #MmGdbusModemSar instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Sar.top_of_page">org.freedesktop.ModemManager1.Modem.Sar</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem_sar(): GdbusModemSar;
            set modem_sar(val: GdbusModemSar);
            /**
             * The #MmGdbusModemSar instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Sar.top_of_page">org.freedesktop.ModemManager1.Modem.Sar</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modemSar(): GdbusModemSar;
            set modemSar(val: GdbusModemSar);
            /**
             * The #MmGdbusModemSignal instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Signal.top_of_page">org.freedesktop.ModemManager1.Modem.Signal</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem_signal(): GdbusModemSignal;
            set modem_signal(val: GdbusModemSignal);
            /**
             * The #MmGdbusModemSignal instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Signal.top_of_page">org.freedesktop.ModemManager1.Modem.Signal</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modemSignal(): GdbusModemSignal;
            set modemSignal(val: GdbusModemSignal);
            /**
             * The #MmGdbusModemSimple instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Simple.top_of_page">org.freedesktop.ModemManager1.Modem.Simple</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem_simple(): GdbusModemSimple;
            set modem_simple(val: GdbusModemSimple);
            /**
             * The #MmGdbusModemSimple instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Simple.top_of_page">org.freedesktop.ModemManager1.Modem.Simple</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modemSimple(): GdbusModemSimple;
            set modemSimple(val: GdbusModemSimple);
            /**
             * The #MmGdbusModemTime instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Time.top_of_page">org.freedesktop.ModemManager1.Modem.Time</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem_time(): GdbusModemTime;
            set modem_time(val: GdbusModemTime);
            /**
             * The #MmGdbusModemTime instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Time.top_of_page">org.freedesktop.ModemManager1.Modem.Time</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modemTime(): GdbusModemTime;
            set modemTime(val: GdbusModemTime);
            /**
             * The #MmGdbusModemVoice instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Voice.top_of_page">org.freedesktop.ModemManager1.Modem.Voice</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem_voice(): GdbusModemVoice;
            set modem_voice(val: GdbusModemVoice);
            /**
             * The #MmGdbusModemVoice instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Voice.top_of_page">org.freedesktop.ModemManager1.Modem.Voice</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modemVoice(): GdbusModemVoice;
            set modemVoice(val: GdbusModemVoice);
            /**
             * The #MmGdbusModem3gpp instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Modem3gpp.top_of_page">org.freedesktop.ModemManager1.Modem.Modem3gpp</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem3gpp(): GdbusModem3gpp;
            set modem3gpp(val: GdbusModem3gpp);
            /**
             * The #MmGdbusModem3gppProfileManager instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.top_of_page">org.freedesktop.ModemManager1.Modem.Modem3gpp.ProfileManager</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem3gpp_profile_manager(): GdbusModem3gppProfileManager;
            set modem3gpp_profile_manager(val: GdbusModem3gppProfileManager);
            /**
             * The #MmGdbusModem3gppProfileManager instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.top_of_page">org.freedesktop.ModemManager1.Modem.Modem3gpp.ProfileManager</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem3gppProfileManager(): GdbusModem3gppProfileManager;
            set modem3gppProfileManager(val: GdbusModem3gppProfileManager);
            /**
             * The #MmGdbusModem3gppUssd instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.top_of_page">org.freedesktop.ModemManager1.Modem.Modem3gpp.Ussd</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem3gpp_ussd(): GdbusModem3gppUssd;
            set modem3gpp_ussd(val: GdbusModem3gppUssd);
            /**
             * The #MmGdbusModem3gppUssd instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.top_of_page">org.freedesktop.ModemManager1.Modem.Modem3gpp.Ussd</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem3gppUssd(): GdbusModem3gppUssd;
            set modem3gppUssd(val: GdbusModem3gppUssd);

            // Inherited methods
            /**
             * Gets the D-Bus interface with name `interface_name` associated with
             * `object,` if any.
             * @param interface_name A D-Bus interface name.
             * @returns %NULL if not found, otherwise a   #GDBusInterface that must be freed with g_object_unref().
             */
            get_interface(interface_name: string): Gio.DBusInterface | null;
            /**
             * Gets the D-Bus interfaces associated with `object`.
             * @returns A list of #GDBusInterface instances.   The returned list must be freed by g_list_free() after each element has been freed   with g_object_unref().
             */
            get_interfaces(): Gio.DBusInterface[];
            /**
             * Gets the object path for `object`.
             * @returns A string owned by @object. Do not free.
             */
            get_object_path(): string;
            /**
             * Gets the D-Bus interface with name `interface_name` associated with
             * `object,` if any.
             * @param interface_name A D-Bus interface name.
             */
            vfunc_get_interface(interface_name: string): Gio.DBusInterface | null;
            /**
             * Gets the D-Bus interfaces associated with `object`.
             */
            vfunc_get_interfaces(): Gio.DBusInterface[];
            /**
             * Gets the object path for `object`.
             */
            vfunc_get_object_path(): string;
            /**
             * Signal handler for the #GDBusObject::interface-added signal.
             * @param interface_
             */
            vfunc_interface_added(interface_: Gio.DBusInterface): void;
            /**
             * Signal handler for the #GDBusObject::interface-removed signal.
             * @param interface_
             */
            vfunc_interface_removed(interface_: Gio.DBusInterface): void;
            /**
             * Gets the #MmGdbusModem instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem.top_of_page">org.freedesktop.ModemManager1.Modem</link> on `object,` if any.
             * @returns A #MmGdbusModem that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
             */
            get_modem(): GdbusModem | null;
            /**
             * Gets the #MmGdbusModem3gpp instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Modem3gpp.top_of_page">org.freedesktop.ModemManager1.Modem.Modem3gpp</link> on `object,` if any.
             * @returns A #MmGdbusModem3gpp that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
             */
            get_modem3gpp(): GdbusModem3gpp | null;
            /**
             * Gets the #MmGdbusModem3gppProfileManager instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.top_of_page">org.freedesktop.ModemManager1.Modem.Modem3gpp.ProfileManager</link> on `object,` if any.
             * @returns A #MmGdbusModem3gppProfileManager that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
             */
            get_modem3gpp_profile_manager(): GdbusModem3gppProfileManager | null;
            /**
             * Gets the #MmGdbusModem3gppUssd instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.top_of_page">org.freedesktop.ModemManager1.Modem.Modem3gpp.Ussd</link> on `object,` if any.
             * @returns A #MmGdbusModem3gppUssd that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
             */
            get_modem3gpp_ussd(): GdbusModem3gppUssd | null;
            /**
             * Gets the #MmGdbusModemCdma instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-ModemCdma.top_of_page">org.freedesktop.ModemManager1.Modem.ModemCdma</link> on `object,` if any.
             * @returns A #MmGdbusModemCdma that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
             */
            get_modem_cdma(): GdbusModemCdma | null;
            /**
             * Gets the #MmGdbusModemFirmware instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Firmware.top_of_page">org.freedesktop.ModemManager1.Modem.Firmware</link> on `object,` if any.
             * @returns A #MmGdbusModemFirmware that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
             */
            get_modem_firmware(): GdbusModemFirmware | null;
            /**
             * Gets the #MmGdbusModemLocation instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Location.top_of_page">org.freedesktop.ModemManager1.Modem.Location</link> on `object,` if any.
             * @returns A #MmGdbusModemLocation that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
             */
            get_modem_location(): GdbusModemLocation | null;
            /**
             * Gets the #MmGdbusModemMessaging instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Messaging.top_of_page">org.freedesktop.ModemManager1.Modem.Messaging</link> on `object,` if any.
             * @returns A #MmGdbusModemMessaging that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
             */
            get_modem_messaging(): GdbusModemMessaging | null;
            /**
             * Gets the #MmGdbusModemOma instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Oma.top_of_page">org.freedesktop.ModemManager1.Modem.Oma</link> on `object,` if any.
             * @returns A #MmGdbusModemOma that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
             */
            get_modem_oma(): GdbusModemOma | null;
            /**
             * Gets the #MmGdbusModemSar instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Sar.top_of_page">org.freedesktop.ModemManager1.Modem.Sar</link> on `object,` if any.
             * @returns A #MmGdbusModemSar that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
             */
            get_modem_sar(): GdbusModemSar | null;
            /**
             * Gets the #MmGdbusModemSignal instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Signal.top_of_page">org.freedesktop.ModemManager1.Modem.Signal</link> on `object,` if any.
             * @returns A #MmGdbusModemSignal that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
             */
            get_modem_signal(): GdbusModemSignal | null;
            /**
             * Gets the #MmGdbusModemSimple instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Simple.top_of_page">org.freedesktop.ModemManager1.Modem.Simple</link> on `object,` if any.
             * @returns A #MmGdbusModemSimple that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
             */
            get_modem_simple(): GdbusModemSimple | null;
            /**
             * Gets the #MmGdbusModemTime instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Time.top_of_page">org.freedesktop.ModemManager1.Modem.Time</link> on `object,` if any.
             * @returns A #MmGdbusModemTime that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
             */
            get_modem_time(): GdbusModemTime | null;
            /**
             * Gets the #MmGdbusModemVoice instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Voice.top_of_page">org.freedesktop.ModemManager1.Modem.Voice</link> on `object,` if any.
             * @returns A #MmGdbusModemVoice that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
             */
            get_modem_voice(): GdbusModemVoice | null;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace GdbusOrgFreedesktopModemManager1Proxy {
            // Constructor properties interface

            interface ConstructorProps
                extends Gio.DBusProxy.ConstructorProps,
                    Gio.AsyncInitable.ConstructorProps,
                    Gio.DBusInterface.ConstructorProps,
                    Gio.Initable.ConstructorProps,
                    GdbusOrgFreedesktopModemManager1.ConstructorProps {}
        }

        /**
         * The #MmGdbusOrgFreedesktopModemManager1Proxy structure contains only private data and should only be accessed using the provided API.
         */
        class GdbusOrgFreedesktopModemManager1Proxy
            extends Gio.DBusProxy
            implements
                Gio.AsyncInitable<GdbusOrgFreedesktopModemManager1Proxy>,
                Gio.DBusInterface,
                Gio.Initable,
                GdbusOrgFreedesktopModemManager1
        {
            static $gtype: GObject.GType<GdbusOrgFreedesktopModemManager1Proxy>;

            // Constructors

            constructor(properties?: Partial<GdbusOrgFreedesktopModemManager1Proxy.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static new_finish(res: Gio.AsyncResult): GdbusOrgFreedesktopModemManager1Proxy;
            // Conflicted with Gio.AsyncInitable.new_finish

            static new_finish(...args: never[]): any;

            static new_for_bus_finish(res: Gio.AsyncResult): GdbusOrgFreedesktopModemManager1Proxy;

            static new_for_bus_sync(
                bus_type: Gio.BusType,
                flags: Gio.DBusProxyFlags,
                name: string,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
            ): GdbusOrgFreedesktopModemManager1Proxy;
            // Conflicted with Gio.DBusProxy.new_for_bus_sync

            static new_for_bus_sync(...args: never[]): any;

            static new_sync(
                connection: Gio.DBusConnection,
                flags: Gio.DBusProxyFlags,
                name: string | null,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
            ): GdbusOrgFreedesktopModemManager1Proxy;
            // Conflicted with Gio.DBusProxy.new_sync

            static new_sync(...args: never[]): any;

            // Static methods

            /**
             * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1.top_of_page">org.freedesktop.ModemManager1</link>. See g_dbus_proxy_new() for more details.
             *
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_org_freedesktop_modem_manager1_proxy_new_finish() to get the result of the operation.
             *
             * See mm_gdbus_org_freedesktop_modem_manager1_proxy_new_sync() for the synchronous, blocking version of this constructor.
             * @param connection A #GDBusConnection.
             * @param flags Flags from the #GDBusProxyFlags enumeration.
             * @param name A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
             * @param object_path An object path.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied.
             */
            static ['new'](
                connection: Gio.DBusConnection,
                flags: Gio.DBusProxyFlags,
                name: string | null,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<GdbusOrgFreedesktopModemManager1Proxy> | null,
            ): void;
            // Conflicted with Gio.DBusProxy.new
            static ['new'](...args: never[]): any;
            /**
             * Like mm_gdbus_org_freedesktop_modem_manager1_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
             *
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_org_freedesktop_modem_manager1_proxy_new_for_bus_finish() to get the result of the operation.
             *
             * See mm_gdbus_org_freedesktop_modem_manager1_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
             * @param bus_type A #GBusType.
             * @param flags Flags from the #GDBusProxyFlags enumeration.
             * @param name A bus name (well-known or unique).
             * @param object_path An object path.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied.
             */
            static new_for_bus(
                bus_type: Gio.BusType,
                flags: Gio.DBusProxyFlags,
                name: string,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<GdbusOrgFreedesktopModemManager1Proxy> | null,
            ): void;
            // Conflicted with Gio.DBusProxy.new_for_bus
            static new_for_bus(...args: never[]): any;

            // Inherited properties
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1.Version">"Version"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get version(): string;
            set version(val: string);

            // Inherited methods
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            init_async(io_priority: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             * @returns %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present.
             */
            init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Finishes the async construction for the various g_async_initable_new
             * calls, returning the created object or %NULL on error.
             * @param res the #GAsyncResult from the callback
             * @returns a newly created #GObject,      or %NULL on error. Free with g_object_unref().
             */
            new_finish(res: Gio.AsyncResult): GdbusOrgFreedesktopModemManager1Proxy;
            // Conflicted with Gio.DBusProxy.new_finish
            new_finish(...args: never[]): any;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            vfunc_init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             */
            vfunc_init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             * @returns A #GDBusObject or %NULL. The returned reference should be freed with g_object_unref().
             */
            get_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             * @returns A #GDBusInterfaceInfo. Do not free.
             */
            get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            set_object(object?: Gio.DBusObject | null): void;
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             */
            vfunc_dup_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             */
            vfunc_get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            vfunc_set_object(object?: Gio.DBusObject | null): void;
            /**
             * Initializes the object implementing the interface.
             *
             * This method is intended for language bindings. If writing in C,
             * g_initable_new() should typically be used instead.
             *
             * The object must be initialized before any real use after initial
             * construction, either with this function or g_async_initable_init_async().
             *
             * Implementations may also support cancellation. If `cancellable` is not %NULL,
             * then initialization can be cancelled by triggering the cancellable object
             * from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
             * the object doesn't support cancellable initialization the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * If the object is not initialized, or initialization returns with an
             * error, then all operations on the object except g_object_ref() and
             * g_object_unref() are considered to be invalid, and have undefined
             * behaviour. See the [description][iface`Gio`.Initable#description] for more details.
             *
             * Callers should not assume that a class which implements #GInitable can be
             * initialized multiple times, unless the class explicitly documents itself as
             * supporting this. Generally, a class’ implementation of init() can assume
             * (and assert) that it will only be called once. Previously, this documentation
             * recommended all #GInitable implementations should be idempotent; that
             * recommendation was relaxed in GLib 2.54.
             *
             * If a class explicitly supports being initialized multiple times, it is
             * recommended that the method is idempotent: multiple calls with the same
             * arguments should return the same results. Only the first call initializes
             * the object; further calls return the result of the first call.
             *
             * One reason why a class might need to support idempotent initialization is if
             * it is designed to be used via the singleton pattern, with a
             * #GObjectClass.constructor that sometimes returns an existing instance.
             * In this pattern, a caller would expect to be able to call g_initable_init()
             * on the result of g_object_new(), regardless of whether it is in fact a new
             * instance.
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @returns %TRUE if successful. If an error has occurred, this function will     return %FALSE and set @error appropriately if present.
             */
            init(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Initializes the object implementing the interface.
             *
             * This method is intended for language bindings. If writing in C,
             * g_initable_new() should typically be used instead.
             *
             * The object must be initialized before any real use after initial
             * construction, either with this function or g_async_initable_init_async().
             *
             * Implementations may also support cancellation. If `cancellable` is not %NULL,
             * then initialization can be cancelled by triggering the cancellable object
             * from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
             * the object doesn't support cancellable initialization the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * If the object is not initialized, or initialization returns with an
             * error, then all operations on the object except g_object_ref() and
             * g_object_unref() are considered to be invalid, and have undefined
             * behaviour. See the [description][iface`Gio`.Initable#description] for more details.
             *
             * Callers should not assume that a class which implements #GInitable can be
             * initialized multiple times, unless the class explicitly documents itself as
             * supporting this. Generally, a class’ implementation of init() can assume
             * (and assert) that it will only be called once. Previously, this documentation
             * recommended all #GInitable implementations should be idempotent; that
             * recommendation was relaxed in GLib 2.54.
             *
             * If a class explicitly supports being initialized multiple times, it is
             * recommended that the method is idempotent: multiple calls with the same
             * arguments should return the same results. Only the first call initializes
             * the object; further calls return the result of the first call.
             *
             * One reason why a class might need to support idempotent initialization is if
             * it is designed to be used via the singleton pattern, with a
             * #GObjectClass.constructor that sometimes returns an existing instance.
             * In this pattern, a caller would expect to be able to call g_initable_init()
             * on the result of g_object_new(), regardless of whether it is in fact a new
             * instance.
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            vfunc_init(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1.InhibitDevice">InhibitDevice()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_org_freedesktop_modem_manager1_call_inhibit_device_finish() to get the result of the operation.
             *
             * See mm_gdbus_org_freedesktop_modem_manager1_call_inhibit_device_sync() for the synchronous, blocking version of this method.
             * @param arg_uid Argument to pass with the method invocation.
             * @param arg_inhibit Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_inhibit_device(
                arg_uid: string,
                arg_inhibit: boolean,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1.InhibitDevice">InhibitDevice()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_org_freedesktop_modem_manager1_call_inhibit_device_finish() to get the result of the operation.
             *
             * See mm_gdbus_org_freedesktop_modem_manager1_call_inhibit_device_sync() for the synchronous, blocking version of this method.
             * @param arg_uid Argument to pass with the method invocation.
             * @param arg_inhibit Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_inhibit_device(
                arg_uid: string,
                arg_inhibit: boolean,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1.InhibitDevice">InhibitDevice()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_org_freedesktop_modem_manager1_call_inhibit_device_finish() to get the result of the operation.
             *
             * See mm_gdbus_org_freedesktop_modem_manager1_call_inhibit_device_sync() for the synchronous, blocking version of this method.
             * @param arg_uid Argument to pass with the method invocation.
             * @param arg_inhibit Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_inhibit_device(
                arg_uid: string,
                arg_inhibit: boolean,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_org_freedesktop_modem_manager1_call_inhibit_device().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_org_freedesktop_modem_manager1_call_inhibit_device().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_inhibit_device_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1.InhibitDevice">InhibitDevice()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_org_freedesktop_modem_manager1_call_inhibit_device() for the asynchronous version of this method.
             * @param arg_uid Argument to pass with the method invocation.
             * @param arg_inhibit Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_inhibit_device_sync(
                arg_uid: string,
                arg_inhibit: boolean,
                cancellable?: Gio.Cancellable | null,
            ): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1.ReportKernelEvent">ReportKernelEvent()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_org_freedesktop_modem_manager1_call_report_kernel_event_finish() to get the result of the operation.
             *
             * See mm_gdbus_org_freedesktop_modem_manager1_call_report_kernel_event_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_report_kernel_event(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1.ReportKernelEvent">ReportKernelEvent()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_org_freedesktop_modem_manager1_call_report_kernel_event_finish() to get the result of the operation.
             *
             * See mm_gdbus_org_freedesktop_modem_manager1_call_report_kernel_event_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_report_kernel_event(
                arg_properties: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1.ReportKernelEvent">ReportKernelEvent()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_org_freedesktop_modem_manager1_call_report_kernel_event_finish() to get the result of the operation.
             *
             * See mm_gdbus_org_freedesktop_modem_manager1_call_report_kernel_event_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_report_kernel_event(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_org_freedesktop_modem_manager1_call_report_kernel_event().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_org_freedesktop_modem_manager1_call_report_kernel_event().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_report_kernel_event_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1.ReportKernelEvent">ReportKernelEvent()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_org_freedesktop_modem_manager1_call_report_kernel_event() for the asynchronous version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_report_kernel_event_sync(arg_properties: GLib.Variant, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1.ScanDevices">ScanDevices()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_org_freedesktop_modem_manager1_call_scan_devices_finish() to get the result of the operation.
             *
             * See mm_gdbus_org_freedesktop_modem_manager1_call_scan_devices_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_scan_devices(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1.ScanDevices">ScanDevices()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_org_freedesktop_modem_manager1_call_scan_devices_finish() to get the result of the operation.
             *
             * See mm_gdbus_org_freedesktop_modem_manager1_call_scan_devices_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_scan_devices(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1.ScanDevices">ScanDevices()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_org_freedesktop_modem_manager1_call_scan_devices_finish() to get the result of the operation.
             *
             * See mm_gdbus_org_freedesktop_modem_manager1_call_scan_devices_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_scan_devices(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_org_freedesktop_modem_manager1_call_scan_devices().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_org_freedesktop_modem_manager1_call_scan_devices().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_scan_devices_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1.ScanDevices">ScanDevices()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_org_freedesktop_modem_manager1_call_scan_devices() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_scan_devices_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1.SetLogging">SetLogging()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_org_freedesktop_modem_manager1_call_set_logging_finish() to get the result of the operation.
             *
             * See mm_gdbus_org_freedesktop_modem_manager1_call_set_logging_sync() for the synchronous, blocking version of this method.
             * @param arg_level Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set_logging(arg_level: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1.SetLogging">SetLogging()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_org_freedesktop_modem_manager1_call_set_logging_finish() to get the result of the operation.
             *
             * See mm_gdbus_org_freedesktop_modem_manager1_call_set_logging_sync() for the synchronous, blocking version of this method.
             * @param arg_level Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_logging(
                arg_level: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1.SetLogging">SetLogging()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_org_freedesktop_modem_manager1_call_set_logging_finish() to get the result of the operation.
             *
             * See mm_gdbus_org_freedesktop_modem_manager1_call_set_logging_sync() for the synchronous, blocking version of this method.
             * @param arg_level Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_logging(
                arg_level: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_org_freedesktop_modem_manager1_call_set_logging().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_org_freedesktop_modem_manager1_call_set_logging().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_logging_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1.SetLogging">SetLogging()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_org_freedesktop_modem_manager1_call_set_logging() for the asynchronous version of this method.
             * @param arg_level Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_logging_sync(arg_level: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1.InhibitDevice">InhibitDevice()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_inhibit_device(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1.ReportKernelEvent">ReportKernelEvent()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_report_kernel_event(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1.ScanDevices">ScanDevices()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_scan_devices(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1.SetLogging">SetLogging()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_set_logging(invocation: Gio.DBusMethodInvocation): void;
            vfunc_handle_inhibit_device(
                invocation: Gio.DBusMethodInvocation,
                arg_uid: string,
                arg_inhibit: boolean,
            ): boolean;
            vfunc_handle_report_kernel_event(
                invocation: Gio.DBusMethodInvocation,
                arg_properties: GLib.Variant,
            ): boolean;
            vfunc_handle_scan_devices(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_set_logging(invocation: Gio.DBusMethodInvocation, arg_level: string): boolean;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace GdbusOrgFreedesktopModemManager1Skeleton {
            // Constructor properties interface

            interface ConstructorProps
                extends Gio.DBusInterfaceSkeleton.ConstructorProps,
                    Gio.DBusInterface.ConstructorProps,
                    GdbusOrgFreedesktopModemManager1.ConstructorProps {}
        }

        /**
         * The #MmGdbusOrgFreedesktopModemManager1Skeleton structure contains only private data and should only be accessed using the provided API.
         */
        class GdbusOrgFreedesktopModemManager1Skeleton
            extends Gio.DBusInterfaceSkeleton
            implements Gio.DBusInterface, GdbusOrgFreedesktopModemManager1
        {
            static $gtype: GObject.GType<GdbusOrgFreedesktopModemManager1Skeleton>;

            // Constructors

            constructor(
                properties?: Partial<GdbusOrgFreedesktopModemManager1Skeleton.ConstructorProps>,
                ...args: any[]
            );

            _init(...args: any[]): void;

            static ['new'](): GdbusOrgFreedesktopModemManager1Skeleton;

            // Inherited properties
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1.Version">"Version"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get version(): string;
            set version(val: string);

            // Inherited methods
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             * @returns A #GDBusObject or %NULL. The returned reference should be freed with g_object_unref().
             */
            get_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             * @returns A #GDBusInterfaceInfo. Do not free.
             */
            get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            set_object(object?: Gio.DBusObject | null): void;
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             */
            vfunc_dup_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             */
            vfunc_get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            vfunc_set_object(object?: Gio.DBusObject | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1.InhibitDevice">InhibitDevice()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_org_freedesktop_modem_manager1_call_inhibit_device_finish() to get the result of the operation.
             *
             * See mm_gdbus_org_freedesktop_modem_manager1_call_inhibit_device_sync() for the synchronous, blocking version of this method.
             * @param arg_uid Argument to pass with the method invocation.
             * @param arg_inhibit Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_inhibit_device(
                arg_uid: string,
                arg_inhibit: boolean,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1.InhibitDevice">InhibitDevice()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_org_freedesktop_modem_manager1_call_inhibit_device_finish() to get the result of the operation.
             *
             * See mm_gdbus_org_freedesktop_modem_manager1_call_inhibit_device_sync() for the synchronous, blocking version of this method.
             * @param arg_uid Argument to pass with the method invocation.
             * @param arg_inhibit Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_inhibit_device(
                arg_uid: string,
                arg_inhibit: boolean,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1.InhibitDevice">InhibitDevice()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_org_freedesktop_modem_manager1_call_inhibit_device_finish() to get the result of the operation.
             *
             * See mm_gdbus_org_freedesktop_modem_manager1_call_inhibit_device_sync() for the synchronous, blocking version of this method.
             * @param arg_uid Argument to pass with the method invocation.
             * @param arg_inhibit Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_inhibit_device(
                arg_uid: string,
                arg_inhibit: boolean,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_org_freedesktop_modem_manager1_call_inhibit_device().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_org_freedesktop_modem_manager1_call_inhibit_device().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_inhibit_device_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1.InhibitDevice">InhibitDevice()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_org_freedesktop_modem_manager1_call_inhibit_device() for the asynchronous version of this method.
             * @param arg_uid Argument to pass with the method invocation.
             * @param arg_inhibit Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_inhibit_device_sync(
                arg_uid: string,
                arg_inhibit: boolean,
                cancellable?: Gio.Cancellable | null,
            ): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1.ReportKernelEvent">ReportKernelEvent()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_org_freedesktop_modem_manager1_call_report_kernel_event_finish() to get the result of the operation.
             *
             * See mm_gdbus_org_freedesktop_modem_manager1_call_report_kernel_event_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_report_kernel_event(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1.ReportKernelEvent">ReportKernelEvent()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_org_freedesktop_modem_manager1_call_report_kernel_event_finish() to get the result of the operation.
             *
             * See mm_gdbus_org_freedesktop_modem_manager1_call_report_kernel_event_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_report_kernel_event(
                arg_properties: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1.ReportKernelEvent">ReportKernelEvent()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_org_freedesktop_modem_manager1_call_report_kernel_event_finish() to get the result of the operation.
             *
             * See mm_gdbus_org_freedesktop_modem_manager1_call_report_kernel_event_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_report_kernel_event(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_org_freedesktop_modem_manager1_call_report_kernel_event().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_org_freedesktop_modem_manager1_call_report_kernel_event().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_report_kernel_event_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1.ReportKernelEvent">ReportKernelEvent()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_org_freedesktop_modem_manager1_call_report_kernel_event() for the asynchronous version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_report_kernel_event_sync(arg_properties: GLib.Variant, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1.ScanDevices">ScanDevices()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_org_freedesktop_modem_manager1_call_scan_devices_finish() to get the result of the operation.
             *
             * See mm_gdbus_org_freedesktop_modem_manager1_call_scan_devices_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_scan_devices(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1.ScanDevices">ScanDevices()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_org_freedesktop_modem_manager1_call_scan_devices_finish() to get the result of the operation.
             *
             * See mm_gdbus_org_freedesktop_modem_manager1_call_scan_devices_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_scan_devices(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1.ScanDevices">ScanDevices()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_org_freedesktop_modem_manager1_call_scan_devices_finish() to get the result of the operation.
             *
             * See mm_gdbus_org_freedesktop_modem_manager1_call_scan_devices_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_scan_devices(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_org_freedesktop_modem_manager1_call_scan_devices().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_org_freedesktop_modem_manager1_call_scan_devices().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_scan_devices_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1.ScanDevices">ScanDevices()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_org_freedesktop_modem_manager1_call_scan_devices() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_scan_devices_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1.SetLogging">SetLogging()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_org_freedesktop_modem_manager1_call_set_logging_finish() to get the result of the operation.
             *
             * See mm_gdbus_org_freedesktop_modem_manager1_call_set_logging_sync() for the synchronous, blocking version of this method.
             * @param arg_level Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set_logging(arg_level: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1.SetLogging">SetLogging()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_org_freedesktop_modem_manager1_call_set_logging_finish() to get the result of the operation.
             *
             * See mm_gdbus_org_freedesktop_modem_manager1_call_set_logging_sync() for the synchronous, blocking version of this method.
             * @param arg_level Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_logging(
                arg_level: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1.SetLogging">SetLogging()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_org_freedesktop_modem_manager1_call_set_logging_finish() to get the result of the operation.
             *
             * See mm_gdbus_org_freedesktop_modem_manager1_call_set_logging_sync() for the synchronous, blocking version of this method.
             * @param arg_level Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_logging(
                arg_level: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_org_freedesktop_modem_manager1_call_set_logging().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_org_freedesktop_modem_manager1_call_set_logging().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_logging_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1.SetLogging">SetLogging()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_org_freedesktop_modem_manager1_call_set_logging() for the asynchronous version of this method.
             * @param arg_level Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_logging_sync(arg_level: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1.InhibitDevice">InhibitDevice()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_inhibit_device(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1.ReportKernelEvent">ReportKernelEvent()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_report_kernel_event(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1.ScanDevices">ScanDevices()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_scan_devices(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1.SetLogging">SetLogging()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_set_logging(invocation: Gio.DBusMethodInvocation): void;
            vfunc_handle_inhibit_device(
                invocation: Gio.DBusMethodInvocation,
                arg_uid: string,
                arg_inhibit: boolean,
            ): boolean;
            vfunc_handle_report_kernel_event(
                invocation: Gio.DBusMethodInvocation,
                arg_properties: GLib.Variant,
            ): boolean;
            vfunc_handle_scan_devices(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_set_logging(invocation: Gio.DBusMethodInvocation, arg_level: string): boolean;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace GdbusSimProxy {
            // Constructor properties interface

            interface ConstructorProps
                extends Gio.DBusProxy.ConstructorProps,
                    Gio.AsyncInitable.ConstructorProps,
                    Gio.DBusInterface.ConstructorProps,
                    Gio.Initable.ConstructorProps,
                    GdbusSim.ConstructorProps {}
        }

        /**
         * The #MmGdbusSimProxy structure contains only private data and should only be accessed using the provided API.
         */
        class GdbusSimProxy
            extends Gio.DBusProxy
            implements Gio.AsyncInitable<GdbusSimProxy>, Gio.DBusInterface, Gio.Initable, GdbusSim
        {
            static $gtype: GObject.GType<GdbusSimProxy>;

            // Constructors

            constructor(properties?: Partial<GdbusSimProxy.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static new_finish(res: Gio.AsyncResult): GdbusSimProxy;
            // Conflicted with Gio.AsyncInitable.new_finish

            static new_finish(...args: never[]): any;

            static new_for_bus_finish(res: Gio.AsyncResult): GdbusSimProxy;

            static new_for_bus_sync(
                bus_type: Gio.BusType,
                flags: Gio.DBusProxyFlags,
                name: string,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
            ): GdbusSimProxy;
            // Conflicted with Gio.DBusProxy.new_for_bus_sync

            static new_for_bus_sync(...args: never[]): any;

            static new_sync(
                connection: Gio.DBusConnection,
                flags: Gio.DBusProxyFlags,
                name: string | null,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
            ): GdbusSimProxy;
            // Conflicted with Gio.DBusProxy.new_sync

            static new_sync(...args: never[]): any;

            // Static methods

            /**
             * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Sim.top_of_page">org.freedesktop.ModemManager1.Sim</link>. See g_dbus_proxy_new() for more details.
             *
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_proxy_new_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_proxy_new_sync() for the synchronous, blocking version of this constructor.
             * @param connection A #GDBusConnection.
             * @param flags Flags from the #GDBusProxyFlags enumeration.
             * @param name A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
             * @param object_path An object path.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied.
             */
            static ['new'](
                connection: Gio.DBusConnection,
                flags: Gio.DBusProxyFlags,
                name: string | null,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<GdbusSimProxy> | null,
            ): void;
            // Conflicted with Gio.DBusProxy.new
            static ['new'](...args: never[]): any;
            /**
             * Like mm_gdbus_sim_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
             *
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_proxy_new_for_bus_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
             * @param bus_type A #GBusType.
             * @param flags Flags from the #GDBusProxyFlags enumeration.
             * @param name A bus name (well-known or unique).
             * @param object_path An object path.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied.
             */
            static new_for_bus(
                bus_type: Gio.BusType,
                flags: Gio.DBusProxyFlags,
                name: string,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<GdbusSimProxy> | null,
            ): void;
            // Conflicted with Gio.DBusProxy.new_for_bus
            static new_for_bus(...args: never[]): any;

            // Inherited properties
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.Active">"Active"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get active(): boolean;
            set active(val: boolean);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.Eid">"Eid"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get eid(): string;
            set eid(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.EmergencyNumbers">"EmergencyNumbers"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get emergency_numbers(): string[];
            set emergency_numbers(val: string[]);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.EmergencyNumbers">"EmergencyNumbers"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get emergencyNumbers(): string[];
            set emergencyNumbers(val: string[]);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.EsimStatus">"EsimStatus"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get esim_status(): number;
            set esim_status(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.EsimStatus">"EsimStatus"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get esimStatus(): number;
            set esimStatus(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.Gid1">"Gid1"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get gid1(): GLib.Variant;
            set gid1(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.Gid2">"Gid2"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get gid2(): GLib.Variant;
            set gid2(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.Imsi">"Imsi"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get imsi(): string;
            set imsi(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.OperatorIdentifier">"OperatorIdentifier"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get operator_identifier(): string;
            set operator_identifier(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.OperatorIdentifier">"OperatorIdentifier"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get operatorIdentifier(): string;
            set operatorIdentifier(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.OperatorName">"OperatorName"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get operator_name(): string;
            set operator_name(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.OperatorName">"OperatorName"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get operatorName(): string;
            set operatorName(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.PreferredNetworks">"PreferredNetworks"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get preferred_networks(): GLib.Variant;
            set preferred_networks(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.PreferredNetworks">"PreferredNetworks"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get preferredNetworks(): GLib.Variant;
            set preferredNetworks(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.Removability">"Removability"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get removability(): number;
            set removability(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.SimIdentifier">"SimIdentifier"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get sim_identifier(): string;
            set sim_identifier(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.SimIdentifier">"SimIdentifier"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get simIdentifier(): string;
            set simIdentifier(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.SimType">"SimType"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get sim_type(): number;
            set sim_type(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.SimType">"SimType"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get simType(): number;
            set simType(val: number);

            // Inherited methods
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            init_async(io_priority: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             * @returns %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present.
             */
            init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Finishes the async construction for the various g_async_initable_new
             * calls, returning the created object or %NULL on error.
             * @param res the #GAsyncResult from the callback
             * @returns a newly created #GObject,      or %NULL on error. Free with g_object_unref().
             */
            new_finish(res: Gio.AsyncResult): GdbusSimProxy;
            // Conflicted with Gio.DBusProxy.new_finish
            new_finish(...args: never[]): any;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            vfunc_init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             */
            vfunc_init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             * @returns A #GDBusObject or %NULL. The returned reference should be freed with g_object_unref().
             */
            get_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             * @returns A #GDBusInterfaceInfo. Do not free.
             */
            get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            set_object(object?: Gio.DBusObject | null): void;
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             */
            vfunc_dup_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             */
            vfunc_get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            vfunc_set_object(object?: Gio.DBusObject | null): void;
            /**
             * Initializes the object implementing the interface.
             *
             * This method is intended for language bindings. If writing in C,
             * g_initable_new() should typically be used instead.
             *
             * The object must be initialized before any real use after initial
             * construction, either with this function or g_async_initable_init_async().
             *
             * Implementations may also support cancellation. If `cancellable` is not %NULL,
             * then initialization can be cancelled by triggering the cancellable object
             * from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
             * the object doesn't support cancellable initialization the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * If the object is not initialized, or initialization returns with an
             * error, then all operations on the object except g_object_ref() and
             * g_object_unref() are considered to be invalid, and have undefined
             * behaviour. See the [description][iface`Gio`.Initable#description] for more details.
             *
             * Callers should not assume that a class which implements #GInitable can be
             * initialized multiple times, unless the class explicitly documents itself as
             * supporting this. Generally, a class’ implementation of init() can assume
             * (and assert) that it will only be called once. Previously, this documentation
             * recommended all #GInitable implementations should be idempotent; that
             * recommendation was relaxed in GLib 2.54.
             *
             * If a class explicitly supports being initialized multiple times, it is
             * recommended that the method is idempotent: multiple calls with the same
             * arguments should return the same results. Only the first call initializes
             * the object; further calls return the result of the first call.
             *
             * One reason why a class might need to support idempotent initialization is if
             * it is designed to be used via the singleton pattern, with a
             * #GObjectClass.constructor that sometimes returns an existing instance.
             * In this pattern, a caller would expect to be able to call g_initable_init()
             * on the result of g_object_new(), regardless of whether it is in fact a new
             * instance.
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @returns %TRUE if successful. If an error has occurred, this function will     return %FALSE and set @error appropriately if present.
             */
            init(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Initializes the object implementing the interface.
             *
             * This method is intended for language bindings. If writing in C,
             * g_initable_new() should typically be used instead.
             *
             * The object must be initialized before any real use after initial
             * construction, either with this function or g_async_initable_init_async().
             *
             * Implementations may also support cancellation. If `cancellable` is not %NULL,
             * then initialization can be cancelled by triggering the cancellable object
             * from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
             * the object doesn't support cancellable initialization the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * If the object is not initialized, or initialization returns with an
             * error, then all operations on the object except g_object_ref() and
             * g_object_unref() are considered to be invalid, and have undefined
             * behaviour. See the [description][iface`Gio`.Initable#description] for more details.
             *
             * Callers should not assume that a class which implements #GInitable can be
             * initialized multiple times, unless the class explicitly documents itself as
             * supporting this. Generally, a class’ implementation of init() can assume
             * (and assert) that it will only be called once. Previously, this documentation
             * recommended all #GInitable implementations should be idempotent; that
             * recommendation was relaxed in GLib 2.54.
             *
             * If a class explicitly supports being initialized multiple times, it is
             * recommended that the method is idempotent: multiple calls with the same
             * arguments should return the same results. Only the first call initializes
             * the object; further calls return the result of the first call.
             *
             * One reason why a class might need to support idempotent initialization is if
             * it is designed to be used via the singleton pattern, with a
             * #GObjectClass.constructor that sometimes returns an existing instance.
             * In this pattern, a caller would expect to be able to call g_initable_init()
             * on the result of g_object_new(), regardless of whether it is in fact a new
             * instance.
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            vfunc_init(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.ChangePin">ChangePin()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_call_change_pin_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_call_change_pin_sync() for the synchronous, blocking version of this method.
             * @param arg_old_pin Argument to pass with the method invocation.
             * @param arg_new_pin Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_change_pin(
                arg_old_pin: string,
                arg_new_pin: string,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.ChangePin">ChangePin()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_call_change_pin_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_call_change_pin_sync() for the synchronous, blocking version of this method.
             * @param arg_old_pin Argument to pass with the method invocation.
             * @param arg_new_pin Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_change_pin(
                arg_old_pin: string,
                arg_new_pin: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.ChangePin">ChangePin()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_call_change_pin_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_call_change_pin_sync() for the synchronous, blocking version of this method.
             * @param arg_old_pin Argument to pass with the method invocation.
             * @param arg_new_pin Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_change_pin(
                arg_old_pin: string,
                arg_new_pin: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_sim_call_change_pin().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_sim_call_change_pin().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_change_pin_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.ChangePin">ChangePin()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_sim_call_change_pin() for the asynchronous version of this method.
             * @param arg_old_pin Argument to pass with the method invocation.
             * @param arg_new_pin Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_change_pin_sync(
                arg_old_pin: string,
                arg_new_pin: string,
                cancellable?: Gio.Cancellable | null,
            ): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.EnablePin">EnablePin()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_call_enable_pin_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_call_enable_pin_sync() for the synchronous, blocking version of this method.
             * @param arg_pin Argument to pass with the method invocation.
             * @param arg_enabled Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_enable_pin(
                arg_pin: string,
                arg_enabled: boolean,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.EnablePin">EnablePin()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_call_enable_pin_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_call_enable_pin_sync() for the synchronous, blocking version of this method.
             * @param arg_pin Argument to pass with the method invocation.
             * @param arg_enabled Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_enable_pin(
                arg_pin: string,
                arg_enabled: boolean,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.EnablePin">EnablePin()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_call_enable_pin_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_call_enable_pin_sync() for the synchronous, blocking version of this method.
             * @param arg_pin Argument to pass with the method invocation.
             * @param arg_enabled Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_enable_pin(
                arg_pin: string,
                arg_enabled: boolean,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_sim_call_enable_pin().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_sim_call_enable_pin().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_enable_pin_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.EnablePin">EnablePin()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_sim_call_enable_pin() for the asynchronous version of this method.
             * @param arg_pin Argument to pass with the method invocation.
             * @param arg_enabled Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_enable_pin_sync(arg_pin: string, arg_enabled: boolean, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.SendPin">SendPin()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_call_send_pin_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_call_send_pin_sync() for the synchronous, blocking version of this method.
             * @param arg_pin Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_send_pin(arg_pin: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.SendPin">SendPin()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_call_send_pin_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_call_send_pin_sync() for the synchronous, blocking version of this method.
             * @param arg_pin Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_send_pin(
                arg_pin: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.SendPin">SendPin()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_call_send_pin_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_call_send_pin_sync() for the synchronous, blocking version of this method.
             * @param arg_pin Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_send_pin(
                arg_pin: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_sim_call_send_pin().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_sim_call_send_pin().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_send_pin_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.SendPin">SendPin()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_sim_call_send_pin() for the asynchronous version of this method.
             * @param arg_pin Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_send_pin_sync(arg_pin: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.SendPuk">SendPuk()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_call_send_puk_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_call_send_puk_sync() for the synchronous, blocking version of this method.
             * @param arg_puk Argument to pass with the method invocation.
             * @param arg_pin Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_send_puk(arg_puk: string, arg_pin: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.SendPuk">SendPuk()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_call_send_puk_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_call_send_puk_sync() for the synchronous, blocking version of this method.
             * @param arg_puk Argument to pass with the method invocation.
             * @param arg_pin Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_send_puk(
                arg_puk: string,
                arg_pin: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.SendPuk">SendPuk()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_call_send_puk_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_call_send_puk_sync() for the synchronous, blocking version of this method.
             * @param arg_puk Argument to pass with the method invocation.
             * @param arg_pin Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_send_puk(
                arg_puk: string,
                arg_pin: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_sim_call_send_puk().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_sim_call_send_puk().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_send_puk_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.SendPuk">SendPuk()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_sim_call_send_puk() for the asynchronous version of this method.
             * @param arg_puk Argument to pass with the method invocation.
             * @param arg_pin Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_send_puk_sync(arg_puk: string, arg_pin: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.SetPreferredNetworks">SetPreferredNetworks()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_call_set_preferred_networks_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_call_set_preferred_networks_sync() for the synchronous, blocking version of this method.
             * @param arg_preferred_networks Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set_preferred_networks(
                arg_preferred_networks: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.SetPreferredNetworks">SetPreferredNetworks()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_call_set_preferred_networks_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_call_set_preferred_networks_sync() for the synchronous, blocking version of this method.
             * @param arg_preferred_networks Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_preferred_networks(
                arg_preferred_networks: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.SetPreferredNetworks">SetPreferredNetworks()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_call_set_preferred_networks_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_call_set_preferred_networks_sync() for the synchronous, blocking version of this method.
             * @param arg_preferred_networks Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_preferred_networks(
                arg_preferred_networks: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_sim_call_set_preferred_networks().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_sim_call_set_preferred_networks().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_preferred_networks_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.SetPreferredNetworks">SetPreferredNetworks()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_sim_call_set_preferred_networks() for the asynchronous version of this method.
             * @param arg_preferred_networks Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_preferred_networks_sync(
                arg_preferred_networks: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
            ): boolean;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.ChangePin">ChangePin()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_change_pin(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.EnablePin">EnablePin()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_enable_pin(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.SendPin">SendPin()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_send_pin(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.SendPuk">SendPuk()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_send_puk(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.SetPreferredNetworks">SetPreferredNetworks()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_set_preferred_networks(invocation: Gio.DBusMethodInvocation): void;
            vfunc_handle_change_pin(
                invocation: Gio.DBusMethodInvocation,
                arg_old_pin: string,
                arg_new_pin: string,
            ): boolean;
            vfunc_handle_enable_pin(
                invocation: Gio.DBusMethodInvocation,
                arg_pin: string,
                arg_enabled: boolean,
            ): boolean;
            vfunc_handle_send_pin(invocation: Gio.DBusMethodInvocation, arg_pin: string): boolean;
            vfunc_handle_send_puk(invocation: Gio.DBusMethodInvocation, arg_puk: string, arg_pin: string): boolean;
            vfunc_handle_set_preferred_networks(
                invocation: Gio.DBusMethodInvocation,
                arg_preferred_networks: GLib.Variant,
            ): boolean;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace GdbusSimSkeleton {
            // Constructor properties interface

            interface ConstructorProps
                extends Gio.DBusInterfaceSkeleton.ConstructorProps,
                    Gio.DBusInterface.ConstructorProps,
                    GdbusSim.ConstructorProps {}
        }

        /**
         * The #MmGdbusSimSkeleton structure contains only private data and should only be accessed using the provided API.
         */
        class GdbusSimSkeleton extends Gio.DBusInterfaceSkeleton implements Gio.DBusInterface, GdbusSim {
            static $gtype: GObject.GType<GdbusSimSkeleton>;

            // Constructors

            constructor(properties?: Partial<GdbusSimSkeleton.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static ['new'](): GdbusSimSkeleton;

            // Inherited properties
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.Active">"Active"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get active(): boolean;
            set active(val: boolean);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.Eid">"Eid"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get eid(): string;
            set eid(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.EmergencyNumbers">"EmergencyNumbers"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get emergency_numbers(): string[];
            set emergency_numbers(val: string[]);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.EmergencyNumbers">"EmergencyNumbers"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get emergencyNumbers(): string[];
            set emergencyNumbers(val: string[]);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.EsimStatus">"EsimStatus"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get esim_status(): number;
            set esim_status(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.EsimStatus">"EsimStatus"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get esimStatus(): number;
            set esimStatus(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.Gid1">"Gid1"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get gid1(): GLib.Variant;
            set gid1(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.Gid2">"Gid2"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get gid2(): GLib.Variant;
            set gid2(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.Imsi">"Imsi"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get imsi(): string;
            set imsi(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.OperatorIdentifier">"OperatorIdentifier"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get operator_identifier(): string;
            set operator_identifier(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.OperatorIdentifier">"OperatorIdentifier"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get operatorIdentifier(): string;
            set operatorIdentifier(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.OperatorName">"OperatorName"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get operator_name(): string;
            set operator_name(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.OperatorName">"OperatorName"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get operatorName(): string;
            set operatorName(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.PreferredNetworks">"PreferredNetworks"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get preferred_networks(): GLib.Variant;
            set preferred_networks(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.PreferredNetworks">"PreferredNetworks"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get preferredNetworks(): GLib.Variant;
            set preferredNetworks(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.Removability">"Removability"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get removability(): number;
            set removability(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.SimIdentifier">"SimIdentifier"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get sim_identifier(): string;
            set sim_identifier(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.SimIdentifier">"SimIdentifier"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get simIdentifier(): string;
            set simIdentifier(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.SimType">"SimType"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get sim_type(): number;
            set sim_type(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.SimType">"SimType"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get simType(): number;
            set simType(val: number);

            // Inherited methods
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             * @returns A #GDBusObject or %NULL. The returned reference should be freed with g_object_unref().
             */
            get_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             * @returns A #GDBusInterfaceInfo. Do not free.
             */
            get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            set_object(object?: Gio.DBusObject | null): void;
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             */
            vfunc_dup_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             */
            vfunc_get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            vfunc_set_object(object?: Gio.DBusObject | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.ChangePin">ChangePin()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_call_change_pin_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_call_change_pin_sync() for the synchronous, blocking version of this method.
             * @param arg_old_pin Argument to pass with the method invocation.
             * @param arg_new_pin Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_change_pin(
                arg_old_pin: string,
                arg_new_pin: string,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.ChangePin">ChangePin()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_call_change_pin_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_call_change_pin_sync() for the synchronous, blocking version of this method.
             * @param arg_old_pin Argument to pass with the method invocation.
             * @param arg_new_pin Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_change_pin(
                arg_old_pin: string,
                arg_new_pin: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.ChangePin">ChangePin()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_call_change_pin_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_call_change_pin_sync() for the synchronous, blocking version of this method.
             * @param arg_old_pin Argument to pass with the method invocation.
             * @param arg_new_pin Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_change_pin(
                arg_old_pin: string,
                arg_new_pin: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_sim_call_change_pin().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_sim_call_change_pin().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_change_pin_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.ChangePin">ChangePin()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_sim_call_change_pin() for the asynchronous version of this method.
             * @param arg_old_pin Argument to pass with the method invocation.
             * @param arg_new_pin Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_change_pin_sync(
                arg_old_pin: string,
                arg_new_pin: string,
                cancellable?: Gio.Cancellable | null,
            ): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.EnablePin">EnablePin()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_call_enable_pin_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_call_enable_pin_sync() for the synchronous, blocking version of this method.
             * @param arg_pin Argument to pass with the method invocation.
             * @param arg_enabled Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_enable_pin(
                arg_pin: string,
                arg_enabled: boolean,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.EnablePin">EnablePin()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_call_enable_pin_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_call_enable_pin_sync() for the synchronous, blocking version of this method.
             * @param arg_pin Argument to pass with the method invocation.
             * @param arg_enabled Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_enable_pin(
                arg_pin: string,
                arg_enabled: boolean,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.EnablePin">EnablePin()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_call_enable_pin_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_call_enable_pin_sync() for the synchronous, blocking version of this method.
             * @param arg_pin Argument to pass with the method invocation.
             * @param arg_enabled Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_enable_pin(
                arg_pin: string,
                arg_enabled: boolean,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_sim_call_enable_pin().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_sim_call_enable_pin().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_enable_pin_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.EnablePin">EnablePin()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_sim_call_enable_pin() for the asynchronous version of this method.
             * @param arg_pin Argument to pass with the method invocation.
             * @param arg_enabled Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_enable_pin_sync(arg_pin: string, arg_enabled: boolean, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.SendPin">SendPin()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_call_send_pin_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_call_send_pin_sync() for the synchronous, blocking version of this method.
             * @param arg_pin Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_send_pin(arg_pin: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.SendPin">SendPin()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_call_send_pin_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_call_send_pin_sync() for the synchronous, blocking version of this method.
             * @param arg_pin Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_send_pin(
                arg_pin: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.SendPin">SendPin()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_call_send_pin_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_call_send_pin_sync() for the synchronous, blocking version of this method.
             * @param arg_pin Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_send_pin(
                arg_pin: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_sim_call_send_pin().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_sim_call_send_pin().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_send_pin_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.SendPin">SendPin()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_sim_call_send_pin() for the asynchronous version of this method.
             * @param arg_pin Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_send_pin_sync(arg_pin: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.SendPuk">SendPuk()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_call_send_puk_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_call_send_puk_sync() for the synchronous, blocking version of this method.
             * @param arg_puk Argument to pass with the method invocation.
             * @param arg_pin Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_send_puk(arg_puk: string, arg_pin: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.SendPuk">SendPuk()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_call_send_puk_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_call_send_puk_sync() for the synchronous, blocking version of this method.
             * @param arg_puk Argument to pass with the method invocation.
             * @param arg_pin Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_send_puk(
                arg_puk: string,
                arg_pin: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.SendPuk">SendPuk()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_call_send_puk_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_call_send_puk_sync() for the synchronous, blocking version of this method.
             * @param arg_puk Argument to pass with the method invocation.
             * @param arg_pin Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_send_puk(
                arg_puk: string,
                arg_pin: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_sim_call_send_puk().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_sim_call_send_puk().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_send_puk_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.SendPuk">SendPuk()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_sim_call_send_puk() for the asynchronous version of this method.
             * @param arg_puk Argument to pass with the method invocation.
             * @param arg_pin Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_send_puk_sync(arg_puk: string, arg_pin: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.SetPreferredNetworks">SetPreferredNetworks()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_call_set_preferred_networks_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_call_set_preferred_networks_sync() for the synchronous, blocking version of this method.
             * @param arg_preferred_networks Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set_preferred_networks(
                arg_preferred_networks: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.SetPreferredNetworks">SetPreferredNetworks()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_call_set_preferred_networks_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_call_set_preferred_networks_sync() for the synchronous, blocking version of this method.
             * @param arg_preferred_networks Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_preferred_networks(
                arg_preferred_networks: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.SetPreferredNetworks">SetPreferredNetworks()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_call_set_preferred_networks_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_call_set_preferred_networks_sync() for the synchronous, blocking version of this method.
             * @param arg_preferred_networks Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_preferred_networks(
                arg_preferred_networks: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_sim_call_set_preferred_networks().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_sim_call_set_preferred_networks().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_preferred_networks_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.SetPreferredNetworks">SetPreferredNetworks()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_sim_call_set_preferred_networks() for the asynchronous version of this method.
             * @param arg_preferred_networks Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_preferred_networks_sync(
                arg_preferred_networks: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
            ): boolean;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.ChangePin">ChangePin()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_change_pin(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.EnablePin">EnablePin()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_enable_pin(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.SendPin">SendPin()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_send_pin(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.SendPuk">SendPuk()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_send_puk(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.SetPreferredNetworks">SetPreferredNetworks()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_set_preferred_networks(invocation: Gio.DBusMethodInvocation): void;
            vfunc_handle_change_pin(
                invocation: Gio.DBusMethodInvocation,
                arg_old_pin: string,
                arg_new_pin: string,
            ): boolean;
            vfunc_handle_enable_pin(
                invocation: Gio.DBusMethodInvocation,
                arg_pin: string,
                arg_enabled: boolean,
            ): boolean;
            vfunc_handle_send_pin(invocation: Gio.DBusMethodInvocation, arg_pin: string): boolean;
            vfunc_handle_send_puk(invocation: Gio.DBusMethodInvocation, arg_puk: string, arg_pin: string): boolean;
            vfunc_handle_set_preferred_networks(
                invocation: Gio.DBusMethodInvocation,
                arg_preferred_networks: GLib.Variant,
            ): boolean;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace GdbusSmsProxy {
            // Constructor properties interface

            interface ConstructorProps
                extends Gio.DBusProxy.ConstructorProps,
                    Gio.AsyncInitable.ConstructorProps,
                    Gio.DBusInterface.ConstructorProps,
                    Gio.Initable.ConstructorProps,
                    GdbusSms.ConstructorProps {}
        }

        /**
         * The #MmGdbusSmsProxy structure contains only private data and should only be accessed using the provided API.
         */
        class GdbusSmsProxy
            extends Gio.DBusProxy
            implements Gio.AsyncInitable<GdbusSmsProxy>, Gio.DBusInterface, Gio.Initable, GdbusSms
        {
            static $gtype: GObject.GType<GdbusSmsProxy>;

            // Constructors

            constructor(properties?: Partial<GdbusSmsProxy.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static new_finish(res: Gio.AsyncResult): GdbusSmsProxy;
            // Conflicted with Gio.AsyncInitable.new_finish

            static new_finish(...args: never[]): any;

            static new_for_bus_finish(res: Gio.AsyncResult): GdbusSmsProxy;

            static new_for_bus_sync(
                bus_type: Gio.BusType,
                flags: Gio.DBusProxyFlags,
                name: string,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
            ): GdbusSmsProxy;
            // Conflicted with Gio.DBusProxy.new_for_bus_sync

            static new_for_bus_sync(...args: never[]): any;

            static new_sync(
                connection: Gio.DBusConnection,
                flags: Gio.DBusProxyFlags,
                name: string | null,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
            ): GdbusSmsProxy;
            // Conflicted with Gio.DBusProxy.new_sync

            static new_sync(...args: never[]): any;

            // Static methods

            /**
             * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Sms.top_of_page">org.freedesktop.ModemManager1.Sms</link>. See g_dbus_proxy_new() for more details.
             *
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sms_proxy_new_finish() to get the result of the operation.
             *
             * See mm_gdbus_sms_proxy_new_sync() for the synchronous, blocking version of this constructor.
             * @param connection A #GDBusConnection.
             * @param flags Flags from the #GDBusProxyFlags enumeration.
             * @param name A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
             * @param object_path An object path.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied.
             */
            static ['new'](
                connection: Gio.DBusConnection,
                flags: Gio.DBusProxyFlags,
                name: string | null,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<GdbusSmsProxy> | null,
            ): void;
            // Conflicted with Gio.DBusProxy.new
            static ['new'](...args: never[]): any;
            /**
             * Like mm_gdbus_sms_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
             *
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sms_proxy_new_for_bus_finish() to get the result of the operation.
             *
             * See mm_gdbus_sms_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
             * @param bus_type A #GBusType.
             * @param flags Flags from the #GDBusProxyFlags enumeration.
             * @param name A bus name (well-known or unique).
             * @param object_path An object path.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied.
             */
            static new_for_bus(
                bus_type: Gio.BusType,
                flags: Gio.DBusProxyFlags,
                name: string,
                object_path: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<GdbusSmsProxy> | null,
            ): void;
            // Conflicted with Gio.DBusProxy.new_for_bus
            static new_for_bus(...args: never[]): any;

            // Inherited properties
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.Class">"Class"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get class(): number;
            set class(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.Data">"Data"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get data(): GLib.Variant;
            set data(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.DeliveryReportRequest">"DeliveryReportRequest"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get delivery_report_request(): boolean;
            set delivery_report_request(val: boolean);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.DeliveryReportRequest">"DeliveryReportRequest"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get deliveryReportRequest(): boolean;
            set deliveryReportRequest(val: boolean);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.DeliveryState">"DeliveryState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get delivery_state(): number;
            set delivery_state(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.DeliveryState">"DeliveryState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get deliveryState(): number;
            set deliveryState(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.DischargeTimestamp">"DischargeTimestamp"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get discharge_timestamp(): string;
            set discharge_timestamp(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.DischargeTimestamp">"DischargeTimestamp"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get dischargeTimestamp(): string;
            set dischargeTimestamp(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.MessageReference">"MessageReference"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get message_reference(): number;
            set message_reference(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.MessageReference">"MessageReference"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get messageReference(): number;
            set messageReference(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.Number">"Number"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get number(): string;
            set number(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.PduType">"PduType"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get pdu_type(): number;
            set pdu_type(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.PduType">"PduType"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get pduType(): number;
            set pduType(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.ServiceCategory">"ServiceCategory"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get service_category(): number;
            set service_category(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.ServiceCategory">"ServiceCategory"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get serviceCategory(): number;
            set serviceCategory(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.SMSC">"SMSC"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get smsc(): string;
            set smsc(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.State">"State"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get state(): number;
            set state(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.Storage">"Storage"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get storage(): number;
            set storage(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.TeleserviceId">"TeleserviceId"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get teleservice_id(): number;
            set teleservice_id(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.TeleserviceId">"TeleserviceId"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get teleserviceId(): number;
            set teleserviceId(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.Text">"Text"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get text(): string;
            set text(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.Timestamp">"Timestamp"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get timestamp(): string;
            set timestamp(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.Validity">"Validity"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get validity(): GLib.Variant;
            set validity(val: GLib.Variant);

            // Inherited methods
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            init_async(io_priority: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             * @returns %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present.
             */
            init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Finishes the async construction for the various g_async_initable_new
             * calls, returning the created object or %NULL on error.
             * @param res the #GAsyncResult from the callback
             * @returns a newly created #GObject,      or %NULL on error. Free with g_object_unref().
             */
            new_finish(res: Gio.AsyncResult): GdbusSmsProxy;
            // Conflicted with Gio.DBusProxy.new_finish
            new_finish(...args: never[]): any;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            vfunc_init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             */
            vfunc_init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             * @returns A #GDBusObject or %NULL. The returned reference should be freed with g_object_unref().
             */
            get_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             * @returns A #GDBusInterfaceInfo. Do not free.
             */
            get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            set_object(object?: Gio.DBusObject | null): void;
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             */
            vfunc_dup_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             */
            vfunc_get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            vfunc_set_object(object?: Gio.DBusObject | null): void;
            /**
             * Initializes the object implementing the interface.
             *
             * This method is intended for language bindings. If writing in C,
             * g_initable_new() should typically be used instead.
             *
             * The object must be initialized before any real use after initial
             * construction, either with this function or g_async_initable_init_async().
             *
             * Implementations may also support cancellation. If `cancellable` is not %NULL,
             * then initialization can be cancelled by triggering the cancellable object
             * from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
             * the object doesn't support cancellable initialization the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * If the object is not initialized, or initialization returns with an
             * error, then all operations on the object except g_object_ref() and
             * g_object_unref() are considered to be invalid, and have undefined
             * behaviour. See the [description][iface`Gio`.Initable#description] for more details.
             *
             * Callers should not assume that a class which implements #GInitable can be
             * initialized multiple times, unless the class explicitly documents itself as
             * supporting this. Generally, a class’ implementation of init() can assume
             * (and assert) that it will only be called once. Previously, this documentation
             * recommended all #GInitable implementations should be idempotent; that
             * recommendation was relaxed in GLib 2.54.
             *
             * If a class explicitly supports being initialized multiple times, it is
             * recommended that the method is idempotent: multiple calls with the same
             * arguments should return the same results. Only the first call initializes
             * the object; further calls return the result of the first call.
             *
             * One reason why a class might need to support idempotent initialization is if
             * it is designed to be used via the singleton pattern, with a
             * #GObjectClass.constructor that sometimes returns an existing instance.
             * In this pattern, a caller would expect to be able to call g_initable_init()
             * on the result of g_object_new(), regardless of whether it is in fact a new
             * instance.
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @returns %TRUE if successful. If an error has occurred, this function will     return %FALSE and set @error appropriately if present.
             */
            init(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Initializes the object implementing the interface.
             *
             * This method is intended for language bindings. If writing in C,
             * g_initable_new() should typically be used instead.
             *
             * The object must be initialized before any real use after initial
             * construction, either with this function or g_async_initable_init_async().
             *
             * Implementations may also support cancellation. If `cancellable` is not %NULL,
             * then initialization can be cancelled by triggering the cancellable object
             * from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
             * the object doesn't support cancellable initialization the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * If the object is not initialized, or initialization returns with an
             * error, then all operations on the object except g_object_ref() and
             * g_object_unref() are considered to be invalid, and have undefined
             * behaviour. See the [description][iface`Gio`.Initable#description] for more details.
             *
             * Callers should not assume that a class which implements #GInitable can be
             * initialized multiple times, unless the class explicitly documents itself as
             * supporting this. Generally, a class’ implementation of init() can assume
             * (and assert) that it will only be called once. Previously, this documentation
             * recommended all #GInitable implementations should be idempotent; that
             * recommendation was relaxed in GLib 2.54.
             *
             * If a class explicitly supports being initialized multiple times, it is
             * recommended that the method is idempotent: multiple calls with the same
             * arguments should return the same results. Only the first call initializes
             * the object; further calls return the result of the first call.
             *
             * One reason why a class might need to support idempotent initialization is if
             * it is designed to be used via the singleton pattern, with a
             * #GObjectClass.constructor that sometimes returns an existing instance.
             * In this pattern, a caller would expect to be able to call g_initable_init()
             * on the result of g_object_new(), regardless of whether it is in fact a new
             * instance.
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            vfunc_init(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sms.Send">Send()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sms_call_send_finish() to get the result of the operation.
             *
             * See mm_gdbus_sms_call_send_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_send(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sms.Send">Send()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sms_call_send_finish() to get the result of the operation.
             *
             * See mm_gdbus_sms_call_send_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_send(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sms.Send">Send()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sms_call_send_finish() to get the result of the operation.
             *
             * See mm_gdbus_sms_call_send_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_send(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_sms_call_send().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_sms_call_send().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_send_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sms.Send">Send()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_sms_call_send() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_send_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sms.Store">Store()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sms_call_store_finish() to get the result of the operation.
             *
             * See mm_gdbus_sms_call_store_sync() for the synchronous, blocking version of this method.
             * @param arg_storage Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_store(arg_storage: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sms.Store">Store()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sms_call_store_finish() to get the result of the operation.
             *
             * See mm_gdbus_sms_call_store_sync() for the synchronous, blocking version of this method.
             * @param arg_storage Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_store(
                arg_storage: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sms.Store">Store()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sms_call_store_finish() to get the result of the operation.
             *
             * See mm_gdbus_sms_call_store_sync() for the synchronous, blocking version of this method.
             * @param arg_storage Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_store(
                arg_storage: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_sms_call_store().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_sms_call_store().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_store_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sms.Store">Store()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_sms_call_store() for the asynchronous version of this method.
             * @param arg_storage Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_store_sync(arg_storage: number, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sms.Send">Send()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_send(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sms.Store">Store()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_store(invocation: Gio.DBusMethodInvocation): void;
            vfunc_handle_send(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_store(invocation: Gio.DBusMethodInvocation, arg_storage: number): boolean;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace GdbusSmsSkeleton {
            // Constructor properties interface

            interface ConstructorProps
                extends Gio.DBusInterfaceSkeleton.ConstructorProps,
                    Gio.DBusInterface.ConstructorProps,
                    GdbusSms.ConstructorProps {}
        }

        /**
         * The #MmGdbusSmsSkeleton structure contains only private data and should only be accessed using the provided API.
         */
        class GdbusSmsSkeleton extends Gio.DBusInterfaceSkeleton implements Gio.DBusInterface, GdbusSms {
            static $gtype: GObject.GType<GdbusSmsSkeleton>;

            // Constructors

            constructor(properties?: Partial<GdbusSmsSkeleton.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static ['new'](): GdbusSmsSkeleton;

            // Inherited properties
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.Class">"Class"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get class(): number;
            set class(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.Data">"Data"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get data(): GLib.Variant;
            set data(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.DeliveryReportRequest">"DeliveryReportRequest"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get delivery_report_request(): boolean;
            set delivery_report_request(val: boolean);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.DeliveryReportRequest">"DeliveryReportRequest"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get deliveryReportRequest(): boolean;
            set deliveryReportRequest(val: boolean);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.DeliveryState">"DeliveryState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get delivery_state(): number;
            set delivery_state(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.DeliveryState">"DeliveryState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get deliveryState(): number;
            set deliveryState(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.DischargeTimestamp">"DischargeTimestamp"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get discharge_timestamp(): string;
            set discharge_timestamp(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.DischargeTimestamp">"DischargeTimestamp"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get dischargeTimestamp(): string;
            set dischargeTimestamp(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.MessageReference">"MessageReference"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get message_reference(): number;
            set message_reference(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.MessageReference">"MessageReference"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get messageReference(): number;
            set messageReference(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.Number">"Number"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get number(): string;
            set number(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.PduType">"PduType"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get pdu_type(): number;
            set pdu_type(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.PduType">"PduType"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get pduType(): number;
            set pduType(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.ServiceCategory">"ServiceCategory"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get service_category(): number;
            set service_category(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.ServiceCategory">"ServiceCategory"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get serviceCategory(): number;
            set serviceCategory(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.SMSC">"SMSC"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get smsc(): string;
            set smsc(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.State">"State"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get state(): number;
            set state(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.Storage">"Storage"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get storage(): number;
            set storage(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.TeleserviceId">"TeleserviceId"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get teleservice_id(): number;
            set teleservice_id(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.TeleserviceId">"TeleserviceId"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get teleserviceId(): number;
            set teleserviceId(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.Text">"Text"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get text(): string;
            set text(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.Timestamp">"Timestamp"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get timestamp(): string;
            set timestamp(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.Validity">"Validity"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get validity(): GLib.Variant;
            set validity(val: GLib.Variant);

            // Inherited methods
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             * @returns A #GDBusObject or %NULL. The returned reference should be freed with g_object_unref().
             */
            get_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             * @returns A #GDBusInterfaceInfo. Do not free.
             */
            get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            set_object(object?: Gio.DBusObject | null): void;
            /**
             * Gets the #GDBusObject that `interface_` belongs to, if any.
             */
            vfunc_dup_object(): Gio.DBusObject | null;
            /**
             * Gets D-Bus introspection information for the D-Bus interface
             * implemented by `interface_`.
             */
            vfunc_get_info(): Gio.DBusInterfaceInfo;
            /**
             * Sets the #GDBusObject for `interface_` to `object`.
             *
             * Note that `interface_` will hold a weak reference to `object`.
             * @param object A #GDBusObject or %NULL.
             */
            vfunc_set_object(object?: Gio.DBusObject | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sms.Send">Send()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sms_call_send_finish() to get the result of the operation.
             *
             * See mm_gdbus_sms_call_send_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_send(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sms.Send">Send()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sms_call_send_finish() to get the result of the operation.
             *
             * See mm_gdbus_sms_call_send_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_send(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sms.Send">Send()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sms_call_send_finish() to get the result of the operation.
             *
             * See mm_gdbus_sms_call_send_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_send(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_sms_call_send().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_sms_call_send().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_send_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sms.Send">Send()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_sms_call_send() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_send_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sms.Store">Store()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sms_call_store_finish() to get the result of the operation.
             *
             * See mm_gdbus_sms_call_store_sync() for the synchronous, blocking version of this method.
             * @param arg_storage Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_store(arg_storage: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sms.Store">Store()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sms_call_store_finish() to get the result of the operation.
             *
             * See mm_gdbus_sms_call_store_sync() for the synchronous, blocking version of this method.
             * @param arg_storage Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_store(
                arg_storage: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sms.Store">Store()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sms_call_store_finish() to get the result of the operation.
             *
             * See mm_gdbus_sms_call_store_sync() for the synchronous, blocking version of this method.
             * @param arg_storage Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_store(
                arg_storage: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_sms_call_store().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_sms_call_store().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_store_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sms.Store">Store()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_sms_call_store() for the asynchronous version of this method.
             * @param arg_storage Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_store_sync(arg_storage: number, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sms.Send">Send()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_send(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sms.Store">Store()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_store(invocation: Gio.DBusMethodInvocation): void;
            vfunc_handle_send(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_store(invocation: Gio.DBusMethodInvocation, arg_storage: number): boolean;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace KernelEventProperties {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {}
        }

        /**
         * The #MMKernelEventProperties structure contains private data and should only be
         * accessed using the provided API.
         */
        class KernelEventProperties extends GObject.Object {
            static $gtype: GObject.GType<KernelEventProperties>;

            // Constructors

            constructor(properties?: Partial<KernelEventProperties.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static ['new'](): KernelEventProperties;

            // Methods

            /**
             * Gets the action.
             * @returns The action. Do not free the returned value, it is owned by @self.
             */
            get_action(): string;
            /**
             * Gets the name.
             * @returns The name. Do not free the returned value, it is owned by @self.
             */
            get_name(): string;
            /**
             * Gets the subsystem.
             * @returns The subsystem. Do not free the returned value, it is owned by @self.
             */
            get_subsystem(): string;
            /**
             * Gets the unique ID of the physical device.
             * @returns The uid. Do not free the returned value, it is owned by @self.
             */
            get_uid(): string;
            /**
             * Sets the action.
             * @param action The action to set.
             */
            set_action(action: string): void;
            /**
             * Sets the name.
             * @param name The name to set.
             */
            set_name(name: string): void;
            /**
             * Sets the subsystem.
             * @param subsystem The subsystem to set.
             */
            set_subsystem(subsystem: string): void;
            /**
             * Sets the unique ID of the physical device.
             * @param uid The uid to set.
             */
            set_uid(uid: string): void;
        }

        namespace Location3gpp {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {}
        }

        /**
         * The #MMLocation3gpp structure contains private data and should
         * only be accessed using the provided API.
         */
        class Location3gpp extends GObject.Object {
            static $gtype: GObject.GType<Location3gpp>;

            // Constructors

            constructor(properties?: Partial<Location3gpp.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Methods

            /**
             * Gets the cell ID of the 3GPP network.
             * @returns the cell ID, or 0 if unknown.
             */
            get_cell_id(): number;
            /**
             * Gets the location area code of the 3GPP network.
             * @returns the location area code, or 0 if unknown.
             */
            get_location_area_code(): number;
            /**
             * Gets the Mobile Country Code of the 3GPP network.
             * @returns the MCC, or 0 if unknown.
             */
            get_mobile_country_code(): number;
            /**
             * Gets the Mobile Network Code of the 3GPP network.
             *
             * Note that 0 may actually be a valid MNC. In general, the MNC should be
             * considered valid just if the reported MCC is valid, as MCC should never
             * be 0.
             * @returns the MNC, or 0 if unknown.
             */
            get_mobile_network_code(): number;
            /**
             * Gets the 3GPP network Mobile Country Code and Mobile Network Code.
             *
             * Returned in the format <literal>"MCCMNC"</literal>, where
             * <literal>MCC</literal> is the three-digit ITU E.212 Mobile Country Code
             * and <literal>MNC</literal> is the two- or three-digit GSM Mobile Network
             * Code. e.g. e<literal>"31026"</literal> or <literal>"310260"</literal>.
             * @returns The operator code, or %NULL if none available.
             */
            get_operator_code(): string;
            /**
             * Gets the location area code of the 3GPP network.
             * @returns the location area code, or 0 if unknown.
             */
            get_tracking_area_code(): number;
        }

        namespace LocationCdmaBs {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {}
        }

        /**
         * The #MMLocationCdmaBs structure contains private data and should
         * only be accessed using the provided API.
         */
        class LocationCdmaBs extends GObject.Object {
            static $gtype: GObject.GType<LocationCdmaBs>;

            // Constructors

            constructor(properties?: Partial<LocationCdmaBs.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Methods

            /**
             * Gets the latitude, in the [-90,90] range.
             * @returns the latitude, or %MM_LOCATION_LATITUDE_UNKNOWN if unknown.
             */
            get_latitude(): number;
            /**
             * Gets the longitude, in the [-180,180] range.
             * @returns the longitude, or %MM_LOCATION_LONGITUDE_UNKNOWN if unknown.
             */
            get_longitude(): number;
        }

        namespace LocationGpsNmea {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {}
        }

        /**
         * The #MMLocationGpsNmea structure contains private data and should
         * only be accessed using the provided API.
         */
        class LocationGpsNmea extends GObject.Object {
            static $gtype: GObject.GType<LocationGpsNmea>;

            // Constructors

            constructor(properties?: Partial<LocationGpsNmea.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Methods

            /**
             * Gets a compilation of all cached traces, in a single string.
             * Traces are separated by '\r\n'.
             * @returns a string containing all traces, or #NULL if none available. The returned value should be freed with g_free().
             */
            build_full(): string;
            /**
             * Gets the last cached value of the specific `trace_type` given.
             * @param trace_type specific NMEA trace type to gather.
             * @returns the NMEA trace, or %NULL if not available. Do not free the returned value, it is owned by @self.
             */
            get_trace(trace_type: string): string;
            /**
             * Gets all cached traces.
             * @returns The list of traces, or %NULL if none available. The returned value should be freed with g_strfreev().
             */
            get_traces(): string[];
        }

        namespace LocationGpsRaw {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {}
        }

        /**
         * The #MMLocationGpsRaw structure contains private data and should
         * only be accessed using the provided API.
         */
        class LocationGpsRaw extends GObject.Object {
            static $gtype: GObject.GType<LocationGpsRaw>;

            // Constructors

            constructor(properties?: Partial<LocationGpsRaw.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Methods

            /**
             * Gets the altitude, in the [-90,90] range.
             * @returns the altitude, or %MM_LOCATION_ALTITUDE_UNKNOWN if unknown.
             */
            get_altitude(): number;
            /**
             * Gets the latitude, in the [-90,90] range.
             * @returns the latitude, or %MM_LOCATION_LATITUDE_UNKNOWN if unknown.
             */
            get_latitude(): number;
            /**
             * Gets the longitude, in the [-180,180] range.
             * @returns the longitude, or %MM_LOCATION_LONGITUDE_UNKNOWN if unknown.
             */
            get_longitude(): number;
            /**
             * Gets the UTC time of the location being reported.
             * @returns a string with the UTC time, or #NULL if unknown. Do not free the returned value, it is owned by @self.
             */
            get_utc_time(): string;
        }

        namespace Manager {
            // Constructor properties interface

            interface ConstructorProps
                extends GdbusObjectManagerClient.ConstructorProps,
                    Gio.AsyncInitable.ConstructorProps,
                    Gio.DBusObjectManager.ConstructorProps,
                    Gio.Initable.ConstructorProps {}
        }

        /**
         * The #MMManager structure contains private data and should only be accessed
         * using the provided API.
         */
        class Manager
            extends GdbusObjectManagerClient
            implements Gio.AsyncInitable<Manager>, Gio.DBusObjectManager, Gio.Initable
        {
            static $gtype: GObject.GType<Manager>;

            // Constructors

            constructor(properties?: Partial<Manager.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static new_finish(res: Gio.AsyncResult): Manager;
            // Conflicted with Gio.AsyncInitable.new_finish

            static new_finish(...args: never[]): any;

            static new_sync(
                connection: Gio.DBusConnection,
                flags: Gio.DBusObjectManagerClientFlags,
                cancellable?: Gio.Cancellable | null,
            ): Manager;
            // Conflicted with ModemManager.GdbusObjectManagerClient.new_sync

            static new_sync(...args: never[]): any;

            // Static methods

            /**
             * Asynchronously creates a #MMManager.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from.
             *
             * You can then call mm_manager_new_finish() to get the result of the operation.
             *
             * See mm_manager_new_sync() for the synchronous, blocking version of this
             * constructor.
             * @param connection A #GDBusConnection.
             * @param flags Flags from the #GDBusObjectManagerClientFlags enumeration.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied.
             */
            static ['new'](
                connection: Gio.DBusConnection,
                flags: Gio.DBusObjectManagerClientFlags,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<Manager> | null,
            ): void;
            // Conflicted with ModemManager.GdbusObjectManagerClient.new
            static ['new'](...args: never[]): any;

            // Methods

            /**
             * Gets the #GDBusProxy interface of the `manager`.
             * @returns The #GDBusProxy interface of @manager, or #NULL if none. The returned object must be freed with g_object_unref().
             */
            get_proxy(): Gio.DBusProxy;
            /**
             * Gets the ModemManager version, as reported by the daemon.
             *
             * It is safe to assume this value never changes during runtime.
             * @returns The version, or %NULL if none available. Do not free the returned value, it belongs to @self.
             */
            get_version(): string;
            /**
             * Asynchronously requests to add an inhibition on the device identified by
             * `uid`.
             *
             * The `uid` must be the unique ID retrieved from an existing #MMModem using
             * mm_modem_get_device(). The caller should keep track of this `uid` and use it
             * in the mm_manager_uninhibit_device() call when the inhibition is no longer
             * required.
             *
             * The inhibition added with this method may also be automatically removed when
             * the caller program disappears from the bus (e.g. if the program ends before
             * having called mm_manager_uninhibit_device() explicitly).
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_manager_inhibit_device_finish() to get the result of the operation.
             *
             * See mm_manager_inhibit_device_sync() for the synchronous, blocking version of
             * this method.
             * @param uid the unique ID of the physical device.
             * @param cancellable A #GCancellable or %NULL.
             */
            inhibit_device(uid: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously requests to add an inhibition on the device identified by
             * `uid`.
             *
             * The `uid` must be the unique ID retrieved from an existing #MMModem using
             * mm_modem_get_device(). The caller should keep track of this `uid` and use it
             * in the mm_manager_uninhibit_device() call when the inhibition is no longer
             * required.
             *
             * The inhibition added with this method may also be automatically removed when
             * the caller program disappears from the bus (e.g. if the program ends before
             * having called mm_manager_uninhibit_device() explicitly).
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_manager_inhibit_device_finish() to get the result of the operation.
             *
             * See mm_manager_inhibit_device_sync() for the synchronous, blocking version of
             * this method.
             * @param uid the unique ID of the physical device.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            inhibit_device(
                uid: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously requests to add an inhibition on the device identified by
             * `uid`.
             *
             * The `uid` must be the unique ID retrieved from an existing #MMModem using
             * mm_modem_get_device(). The caller should keep track of this `uid` and use it
             * in the mm_manager_uninhibit_device() call when the inhibition is no longer
             * required.
             *
             * The inhibition added with this method may also be automatically removed when
             * the caller program disappears from the bus (e.g. if the program ends before
             * having called mm_manager_uninhibit_device() explicitly).
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_manager_inhibit_device_finish() to get the result of the operation.
             *
             * See mm_manager_inhibit_device_sync() for the synchronous, blocking version of
             * this method.
             * @param uid the unique ID of the physical device.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            inhibit_device(
                uid: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_manager_inhibit_device().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_manager_inhibit_device().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            inhibit_device_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously requests to add an inhibition on the device identified by `uid`.
             *
             * The `uid` must be the unique ID retrieved from an existing #MMModem using
             * mm_modem_get_device(). The caller should keep track of this `uid` and use it
             * in the mm_manager_uninhibit_device_sync() call when the inhibition is no
             * longer required.
             *
             * The inhibition added with this method may also be automatically removed when
             * the caller program disappears from the bus (e.g. if the program ends before
             * having called mm_manager_uninhibit_device_sync() explicitly).
             *
             * See mm_manager_inhibit_device() for the asynchronous version of this method.
             * @param uid the unique ID of the physical device.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            inhibit_device_sync(uid: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Gets the #GDBusProxy interface of the `manager`.
             * @returns The #GDBusProxy interface of @manager, or #NULL if none. Do not free the returned object, it is owned by @manager.
             */
            peek_proxy(): Gio.DBusProxy;
            /**
             * Asynchronously report kernel event.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_manager_report_kernel_event_finish() to get the result of the operation.
             *
             * See mm_manager_report_kernel_event_sync() for the synchronous, blocking
             * version of this method.
             * @param properties the properties of the kernel event.
             * @param cancellable A #GCancellable or %NULL.
             */
            report_kernel_event(
                properties: KernelEventProperties,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronously report kernel event.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_manager_report_kernel_event_finish() to get the result of the operation.
             *
             * See mm_manager_report_kernel_event_sync() for the synchronous, blocking
             * version of this method.
             * @param properties the properties of the kernel event.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            report_kernel_event(
                properties: KernelEventProperties,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously report kernel event.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_manager_report_kernel_event_finish() to get the result of the operation.
             *
             * See mm_manager_report_kernel_event_sync() for the synchronous, blocking
             * version of this method.
             * @param properties the properties of the kernel event.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            report_kernel_event(
                properties: KernelEventProperties,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_manager_report_kernel_event().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_manager_report_kernel_event().
             * @returns %TRUE if the operation succeeded, %FALSE if @error is set.
             */
            report_kernel_event_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously report kernel event.
             *
             * The calling thread is blocked until a reply is received.
             *
             * See mm_manager_report_kernel_event() for the asynchronous version of this
             * method.
             * @param properties the properties of the kernel event.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the operation succeeded, %FALSE if @error is set.
             */
            report_kernel_event_sync(properties: KernelEventProperties, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously requests to scan looking for devices.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_manager_scan_devices_finish() to get the result of the operation.
             *
             * See mm_manager_scan_devices_sync() for the synchronous, blocking version of
             * this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            scan_devices(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously requests to scan looking for devices.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_manager_scan_devices_finish() to get the result of the operation.
             *
             * See mm_manager_scan_devices_sync() for the synchronous, blocking version of
             * this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            scan_devices(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously requests to scan looking for devices.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_manager_scan_devices_finish() to get the result of the operation.
             *
             * See mm_manager_scan_devices_sync() for the synchronous, blocking version of
             * this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            scan_devices(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_manager_scan_devices().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_manager_scan_devices().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            scan_devices_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously requests to scan looking for devices.
             *
             * The calling thread is blocked until a reply is received.
             *
             * See mm_manager_scan_devices() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            scan_devices_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously requests to set the specified logging level in the daemon.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_manager_set_logging_finish() to get the result of the operation.
             *
             * See mm_manager_set_logging_sync() for the synchronous, blocking version of
             * this method.
             * @param level the login level to set.
             * @param cancellable A #GCancellable or %NULL.
             */
            set_logging(level: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously requests to set the specified logging level in the daemon.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_manager_set_logging_finish() to get the result of the operation.
             *
             * See mm_manager_set_logging_sync() for the synchronous, blocking version of
             * this method.
             * @param level the login level to set.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            set_logging(
                level: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously requests to set the specified logging level in the daemon.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_manager_set_logging_finish() to get the result of the operation.
             *
             * See mm_manager_set_logging_sync() for the synchronous, blocking version of
             * this method.
             * @param level the login level to set.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            set_logging(
                level: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_manager_set_logging().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_manager_set_logging().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            set_logging_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously requests to set the specified logging level in the daemon.
             *
             * The calling thread is blocked until a reply is received.
             *
             * See mm_manager_set_logging() for the asynchronous version of this method.
             * @param level the login level to set.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            set_logging_sync(level: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously requests to remove an inhibition on the device identified by
             * `uid`.
             *
             * The `uid` must be the same unique ID that was sent in the inhibition request.
             *
             * Only the same program that placed an inhibition on a given device is able to
             * remove the inhibition.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_manager_uninhibit_device_finish() to get the result of the operation.
             *
             * See mm_manager_uninhibit_device_sync() for the synchronous, blocking version
             * of this method.
             * @param uid the unique ID of the physical device.
             * @param cancellable A #GCancellable or %NULL.
             */
            uninhibit_device(uid: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously requests to remove an inhibition on the device identified by
             * `uid`.
             *
             * The `uid` must be the same unique ID that was sent in the inhibition request.
             *
             * Only the same program that placed an inhibition on a given device is able to
             * remove the inhibition.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_manager_uninhibit_device_finish() to get the result of the operation.
             *
             * See mm_manager_uninhibit_device_sync() for the synchronous, blocking version
             * of this method.
             * @param uid the unique ID of the physical device.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            uninhibit_device(
                uid: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously requests to remove an inhibition on the device identified by
             * `uid`.
             *
             * The `uid` must be the same unique ID that was sent in the inhibition request.
             *
             * Only the same program that placed an inhibition on a given device is able to
             * remove the inhibition.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_manager_uninhibit_device_finish() to get the result of the operation.
             *
             * See mm_manager_uninhibit_device_sync() for the synchronous, blocking version
             * of this method.
             * @param uid the unique ID of the physical device.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            uninhibit_device(
                uid: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_manager_uninhibit_device().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_manager_uninhibit_device().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            uninhibit_device_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously requests to remove an inhibition on the device identified by
             * `uid`.
             *
             * The `uid` must be the same unique ID that was sent in the inhibition request.
             *
             * Only the same program that placed an inhibition on a given device is able to
             * remove the inhibition.
             *
             * See mm_manager_uninhibit_device() for the asynchronous version of this
             * method.
             * @param uid the unique ID of the physical device.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            uninhibit_device_sync(uid: string, cancellable?: Gio.Cancellable | null): boolean;

            // Inherited methods
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            init_async(io_priority: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             * @returns %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present.
             */
            init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Finishes the async construction for the various g_async_initable_new
             * calls, returning the created object or %NULL on error.
             * @param res the #GAsyncResult from the callback
             * @returns a newly created #GObject,      or %NULL on error. Free with g_object_unref().
             */
            new_finish(res: Gio.AsyncResult): Manager;
            // Conflicted with ModemManager.GdbusObjectManagerClient.new_finish
            new_finish(...args: never[]): any;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            vfunc_init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             */
            vfunc_init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace Modem {
            // Constructor properties interface

            interface ConstructorProps
                extends GdbusModemProxy.ConstructorProps,
                    Gio.AsyncInitable.ConstructorProps,
                    Gio.DBusInterface.ConstructorProps,
                    Gio.Initable.ConstructorProps,
                    GdbusModem.ConstructorProps {}
        }

        /**
         * The #MMModem structure contains private data and should only be accessed
         * using the provided API.
         */
        class Modem
            extends GdbusModemProxy
            implements Gio.AsyncInitable<Modem>, Gio.DBusInterface, Gio.Initable, GdbusModem
        {
            static $gtype: GObject.GType<Modem>;

            // Constructors

            constructor(properties?: Partial<Modem.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Static methods

            /**
             * Gets the list of pending network-initiated OMA sessions.
             * @param self A #MMModem.
             */
            static get_pending_network_initiated_sessions(
                self: ModemOma,
            ): [boolean, OmaPendingNetworkInitiatedSession[]];
            /**
             * Gets the list of pending network-initiated OMA sessions.
             * @param self A #MMModem.
             */
            static peek_pending_network_initiated_sessions(
                self: ModemOma,
            ): [boolean, OmaPendingNetworkInitiatedSession[]];

            // Methods

            /**
             * Asynchronously runs an AT command in the modem.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_command_finish() to get the result of the operation.
             *
             * See mm_modem_command_sync() for the synchronous, blocking version of this
             * method.
             * @param cmd AT command to run.
             * @param timeout Maximum time to wait for the response, in seconds.
             * @param cancellable A #GCancellable or %NULL.
             */
            command(cmd: string, timeout: number, cancellable?: Gio.Cancellable | null): Promise<string>;
            /**
             * Asynchronously runs an AT command in the modem.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_command_finish() to get the result of the operation.
             *
             * See mm_modem_command_sync() for the synchronous, blocking version of this
             * method.
             * @param cmd AT command to run.
             * @param timeout Maximum time to wait for the response, in seconds.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            command(
                cmd: string,
                timeout: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously runs an AT command in the modem.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_command_finish() to get the result of the operation.
             *
             * See mm_modem_command_sync() for the synchronous, blocking version of this
             * method.
             * @param cmd AT command to run.
             * @param timeout Maximum time to wait for the response, in seconds.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            command(
                cmd: string,
                timeout: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<string> | void;
            /**
             * Finishes an operation started with mm_modem_command().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_command().
             * @returns A newly allocated string with the reply to the command, or #NULL if @error is set. The returned value should be freed with g_free().
             */
            command_finish(res: Gio.AsyncResult): string;
            /**
             * Synchronously runs an AT command in the modem.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_command() for the asynchronous version of this method.
             * @param cmd AT command to run.
             * @param timeout Maximum time to wait for the response, in seconds.
             * @param cancellable A #GCancellable or %NULL.
             * @returns A newly allocated string with the reply to the command, or #NULL if @error is set. The returned value should be freed with g_free().
             */
            command_sync(cmd: string, timeout: number, cancellable?: Gio.Cancellable | null): string;
            /**
             * Asynchronously creates a new packet data bearer in the #MMModem.
             *
             * This request may fail if the modem does not support additional bearers,
             * if too many bearers are already defined, or if `properties` are invalid.
             *
             * See <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.CreateBearer">CreateBearer</link>
             * to check which properties may be passed.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_create_bearer_finish() to get the result of the operation.
             *
             * See mm_modem_create_bearer_sync() for the synchronous, blocking version of
             * this method.
             * @param properties A #MMBearerProperties object with the properties to use.
             * @param cancellable A #GCancellable or %NULL.
             */
            create_bearer(properties: BearerProperties, cancellable?: Gio.Cancellable | null): Promise<Bearer>;
            /**
             * Asynchronously creates a new packet data bearer in the #MMModem.
             *
             * This request may fail if the modem does not support additional bearers,
             * if too many bearers are already defined, or if `properties` are invalid.
             *
             * See <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.CreateBearer">CreateBearer</link>
             * to check which properties may be passed.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_create_bearer_finish() to get the result of the operation.
             *
             * See mm_modem_create_bearer_sync() for the synchronous, blocking version of
             * this method.
             * @param properties A #MMBearerProperties object with the properties to use.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            create_bearer(
                properties: BearerProperties,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously creates a new packet data bearer in the #MMModem.
             *
             * This request may fail if the modem does not support additional bearers,
             * if too many bearers are already defined, or if `properties` are invalid.
             *
             * See <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.CreateBearer">CreateBearer</link>
             * to check which properties may be passed.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_create_bearer_finish() to get the result of the operation.
             *
             * See mm_modem_create_bearer_sync() for the synchronous, blocking version of
             * this method.
             * @param properties A #MMBearerProperties object with the properties to use.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            create_bearer(
                properties: BearerProperties,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<Bearer> | void;
            /**
             * Finishes an operation started with mm_modem_create_bearer().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_create_bearer().
             * @returns A newly created #MMBearer, or %NULL if @error is set.
             */
            create_bearer_finish(res: Gio.AsyncResult): Bearer;
            /**
             * Synchronously creates a new packet data bearer in the #MMModem.
             *
             * This request may fail if the modem does not support additional bearers,
             * if too many bearers are already defined, or if `properties` are invalid.
             *
             * See <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.CreateBearer">CreateBearer</link>
             * to check which properties may be passed.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_create_bearer() for the asynchronous version of this method.
             * @param properties A #MMBearerProperties object with the properties to use.
             * @param cancellable A #GCancellable or %NULL.
             * @returns A newly created #MMBearer, or %NULL if @error is set.
             */
            create_bearer_sync(properties: BearerProperties, cancellable?: Gio.Cancellable | null): Bearer;
            /**
             * Asynchronously deletes a given bearer from the #MMModem.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_delete_bearer_finish() to get the result of the operation.
             *
             * See mm_modem_delete_bearer_sync() for the synchronous, blocking version of
             * this method.
             * @param bearer Path of the bearer to delete.
             * @param cancellable A #GCancellable or %NULL.
             */
            delete_bearer(bearer: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously deletes a given bearer from the #MMModem.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_delete_bearer_finish() to get the result of the operation.
             *
             * See mm_modem_delete_bearer_sync() for the synchronous, blocking version of
             * this method.
             * @param bearer Path of the bearer to delete.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            delete_bearer(
                bearer: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously deletes a given bearer from the #MMModem.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_delete_bearer_finish() to get the result of the operation.
             *
             * See mm_modem_delete_bearer_sync() for the synchronous, blocking version of
             * this method.
             * @param bearer Path of the bearer to delete.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            delete_bearer(
                bearer: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_modem_delete_bearer().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_delete_bearer().
             * @returns %TRUE if the bearer was deleted, %FALSE if @error is set.
             */
            delete_bearer_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously deletes a given bearer from the #MMModem.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_delete_bearer() for the asynchronous version of this method.
             * @param bearer Path of the bearer to delete.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the bearer was deleted, %FALSE if @error is set.
             */
            delete_bearer_sync(bearer: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously tries to disable the #MMModem. When disabled, the modem enters
             * low-power state and no network-related operations are available.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_disable_finish() to get the result of the operation.
             *
             * See mm_modem_disable_sync() for the synchronous, blocking version of this
             * method.
             * @param cancellable A #GCancellable or %NULL.
             */
            disable(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously tries to disable the #MMModem. When disabled, the modem enters
             * low-power state and no network-related operations are available.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_disable_finish() to get the result of the operation.
             *
             * See mm_modem_disable_sync() for the synchronous, blocking version of this
             * method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            disable(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously tries to disable the #MMModem. When disabled, the modem enters
             * low-power state and no network-related operations are available.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_disable_finish() to get the result of the operation.
             *
             * See mm_modem_disable_sync() for the synchronous, blocking version of this
             * method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            disable(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_modem_disable().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_disable().
             * @returns %TRUE if the modem was properly disabled, %FALSE if @error is set.
             */
            disable_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously tries to disable the #MMModem. When disabled, the modem enters
             * low-power state and no network-related operations are available.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_disable() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the modem was properly disabled, %FALSE if @error is set.
             */
            disable_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Gets a copy of the DBus paths of the #MMBearer handled in this #MMModem.
             * @returns The DBus paths of the #MMBearer handled in this #MMModem, or %NULL if none available. The returned value should be freed with g_strfreev().
             */
            dup_bearer_paths(): string[];
            /**
             * Gets a copy of the carrier-specific configuration (MCFG) in use, as reported
             * by this #MMModem.
             * @returns The carrier configuration, or %NULL if none available. The returned value should be freed with g_free().
             */
            dup_carrier_configuration(): string;
            /**
             * Gets a copy of the carrier-specific configuration revision in use, as
             * reported by this #MMModem.
             * @returns The carrier configuration revision, or %NULL if none available. The returned value should be freed with g_free().
             */
            dup_carrier_configuration_revision(): string;
            /**
             * Gets a copy of the physical modem device reference (ie, USB, PCI, PCMCIA
             * device), which may be dependent upon the operating system.
             * @returns The device, or %NULL if none available. The returned value should be freed with g_free().
             */
            dup_device(): string;
            /**
             * Gets a copy of a best-effort device identifier based on various device
             * information like model name, firmware revision, USB/PCI/PCMCIA IDs, and other
             * properties.
             *
             * This ID is not guaranteed to be unique and may be shared between
             * identical devices with the same firmware, but is intended to be "unique
             * enough" for use as a casual device identifier for various user
             * experience operations.
             *
             * This is not the device's IMEI or ESN since those may not be available
             * before unlocking the device via a PIN.
             * @returns The device identifier, or %NULL if none available. The returned value should be freed with g_free().
             */
            dup_device_identifier(): string;
            /**
             * Gets a copy of the Operating System device driver handling communication with
             * the modem hardware.
             * @returns The drivers, or %NULL if none available. The returned value should be freed with g_strfreev().
             */
            dup_drivers(): string[];
            /**
             * Gets a copy of the identity of the #MMModem.
             *
             * This will be the IMEI number for GSM devices and the hex-format ESN/MEID
             * for CDMA devices.
             * @returns The equipment identifier, or %NULL if none available. The returned value should be freed with g_free().
             */
            dup_equipment_identifier(): string;
            /**
             * Gets a copy of the equipment hardware revision, as reported by this #MMModem.
             * @returns The equipment hardware revision, or %NULL if none available. The returned value should be freed with g_free().
             */
            dup_hardware_revision(): string;
            /**
             * Gets a copy of the equipment manufacturer, as reported by this #MMModem.
             * @returns The equipment manufacturer, or %NULL if none available. The returned value should be freed with g_free().
             */
            dup_manufacturer(): string;
            /**
             * Gets a copy of the equipment model, as reported by this #MMModem.
             * @returns The equipment model, or %NULL if none available. The returned value should be freed with g_free().
             */
            dup_model(): string;
            /**
             * Gets a copy of the list of numbers (e.g. MSISDN in 3GPP) being currently
             * handled by this modem.
             * @returns The list of own numbers or %NULL if none is available. The returned value should be freed with g_strfreev().
             */
            dup_own_numbers(): string[];
            /**
             * Gets a copy of the DBus path of the #MMObject object which implements this
             * interface.
             * @returns The DBus path of the #MMObject. The returned value should be freed with g_free().
             */
            dup_path(): string;
            /**
             * Gets a copy of the physical modem device path (ie, USB, PCI, PCMCIA
             * device), which may be dependent upon the operating system.
             * @returns The physdev path, or %NULL if none available. The returned value should be freed with g_free().
             */
            dup_physdev(): string;
            /**
             * Gets a copy of the name of the plugin handling this #MMModem.
             * @returns The name of the plugin, or %NULL if none available. The returned value should be freed with g_free().
             */
            dup_plugin(): string;
            /**
             * Gets a copy of the name of the primary port controlling this #MMModem.
             * @returns The name of the primary port. The returned value should be freed with g_free().
             */
            dup_primary_port(): string;
            /**
             * Gets a copy of the equipment revision, as reported by this #MMModem.
             * @returns The equipment revision, or %NULL if none available. The returned value should be freed with g_free().
             */
            dup_revision(): string;
            /**
             * Gets a copy of the DBus path of the #MMSim handled in this #MMModem.
             * @returns The DBus path of the #MMSim handled in this #MMModem, or %NULL if none available. The returned value should be freed with g_free().
             */
            dup_sim_path(): string;
            /**
             * Gets a copy of the DBus paths of the #MMSim objects available in the
             * different SIM slots handled in this #MMModem. If a given SIM slot at a given
             * index doesn't have a SIM card available, an empty object path will be given.
             * This list includes the currently active SIM object path.
             * @returns The DBus paths of the #MMSim objects handled in this #MMModem, or %NULL if none available. The returned value should be freed with g_strfreev().
             */
            dup_sim_slot_paths(): string[];
            /**
             * Asynchronously tries to enable the #MMModem. When enabled, the modem's radio
             * is powered on and data sessions, voice calls, location services, and Short
             * Message Service may be available.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_enable_finish() to get the result of the operation.
             *
             * See mm_modem_enable_sync() for the synchronous, blocking version of this
             * method.
             * @param cancellable A #GCancellable or %NULL.
             */
            enable(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously tries to enable the #MMModem. When enabled, the modem's radio
             * is powered on and data sessions, voice calls, location services, and Short
             * Message Service may be available.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_enable_finish() to get the result of the operation.
             *
             * See mm_modem_enable_sync() for the synchronous, blocking version of this
             * method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            enable(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously tries to enable the #MMModem. When enabled, the modem's radio
             * is powered on and data sessions, voice calls, location services, and Short
             * Message Service may be available.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_enable_finish() to get the result of the operation.
             *
             * See mm_modem_enable_sync() for the synchronous, blocking version of this
             * method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            enable(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_modem_enable().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_enable().
             * @returns %TRUE if the modem was properly enabled, %FALSE if @error is set.
             */
            enable_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously tries to enable the #MMModem. When enabled, the modem's radio
             * is powered on and data sessions, voice calls, location services, and Short
             * Message Service may be available.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_enable() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the modem was properly enabled, %FALSE if @error is set.
             */
            enable_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously clears the modem's configuration (including persistent
             * configuration and state), and returns the device to a factory-default state.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_factory_reset_finish() to get the result of the operation.
             *
             * See mm_modem_factory_reset_sync() for the synchronous, blocking version of
             * this method.
             * @param code Carrier-supplied code required to reset the modem.
             * @param cancellable A #GCancellable or %NULL.
             */
            factory_reset(code: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously clears the modem's configuration (including persistent
             * configuration and state), and returns the device to a factory-default state.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_factory_reset_finish() to get the result of the operation.
             *
             * See mm_modem_factory_reset_sync() for the synchronous, blocking version of
             * this method.
             * @param code Carrier-supplied code required to reset the modem.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            factory_reset(
                code: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously clears the modem's configuration (including persistent
             * configuration and state), and returns the device to a factory-default state.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_factory_reset_finish() to get the result of the operation.
             *
             * See mm_modem_factory_reset_sync() for the synchronous, blocking version of
             * this method.
             * @param code Carrier-supplied code required to reset the modem.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            factory_reset(
                code: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_modem_factory_reset().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_factory_reset().
             * @returns %TRUE if the factory_reset was successful, %FALSE if @error is set.
             */
            factory_reset_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously clears the modem's configuration (including persistent
             * configuration and state), and returns the device to a factory-default state.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_factory_reset() for the asynchronous version of this method.
             * @param code Carrier-supplied code required to reset the modem.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the factory reset was successful, %FALSE if @error is set.
             */
            factory_reset_sync(code: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Gets the current network access technology used by the #MMModem to
             * communicate with the network.
             * @returns A ##MMModemAccessTechnology value.
             */
            get_access_technologies(): ModemAccessTechnology;
            /**
             * Gets the DBus paths of the #MMBearer handled in this #MMModem.
             *
             * <warning>The returned value is only valid until the property changes so it is
             * only safe to use this function on the thread where `self` was constructed. Use
             * mm_modem_dup_bearer_paths() if on another thread.</warning>
             * @returns The DBus paths of the #MMBearer handled in this #MMModem, or %NULL if none available. Do not free the returned value, it belongs to @self.
             */
            get_bearer_paths(): string[];
            /**
             * Gets the carrier-specific configuration (MCFG) in use, as reported by this
             * #MMModem.
             *
             * <warning>The returned value is only valid until the property changes so it is
             * only safe to use this function on the thread where `self` was constructed. Use
             * mm_modem_dup_carrier_configuration() if on another thread.</warning>
             * @returns The carrier configuration, or %NULL if none available. Do not free the returned value, it belongs to @self.
             */
            get_carrier_configuration(): string;
            /**
             * Gets the carrier-specific configuration revision in use, as reported by this
             * #MMModem.
             *
             * <warning>The returned value is only valid until the property changes so it is
             * only safe to use this function on the thread where `self` was constructed. Use
             * mm_modem_dup_carrier_configuration() if on another thread.</warning>
             * @returns The carrier configuration revision, or %NULL if none available. Do not free the returned value, it belongs to @self.
             */
            get_carrier_configuration_revision(): string;
            /**
             * Asynchronously requests to get info about serving and neighboring cells.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_get_cell_info_finish() to get the result of the operation.
             *
             * See mm_modem_get_cell_info_sync() for the synchronous, blocking version of this
             * method.
             * @param cancellable A #GCancellable or %NULL.
             */
            get_cell_info(cancellable?: Gio.Cancellable | null): Promise<CellInfo[]>;
            /**
             * Asynchronously requests to get info about serving and neighboring cells.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_get_cell_info_finish() to get the result of the operation.
             *
             * See mm_modem_get_cell_info_sync() for the synchronous, blocking version of this
             * method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            get_cell_info(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously requests to get info about serving and neighboring cells.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_get_cell_info_finish() to get the result of the operation.
             *
             * See mm_modem_get_cell_info_sync() for the synchronous, blocking version of this
             * method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            get_cell_info(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<CellInfo[]> | void;
            /**
             * Finishes an operation started with mm_modem_get_cell_info().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_get_cell_info().
             * @returns a list of #MMCellInfo objects, or #NULL if @error is set. The returned value should be freed with g_list_free_full() using g_object_unref() as #GDestroyNotify function.
             */
            get_cell_info_finish(res: Gio.AsyncResult): CellInfo[];
            /**
             * Synchronously requests to get info about serving and neighboring cells.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_get_cell_info() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns a list of #MMCellInfo objects, or #NULL if @error is set. The returned value should be freed with g_list_free_full() using g_object_unref() as #GDestroyNotify function.
             */
            get_cell_info_sync(cancellable?: Gio.Cancellable | null): CellInfo[];
            /**
             * Gets the list of radio frequency and technology bands the #MMModem is
             * currently using when connecting to a network.
             *
             * For POTS devices, only the #MM_MODEM_BAND_ANY band is supported.
             * @returns %TRUE if @bands and @n_bands are set, %FALSE otherwise.
             */
            get_current_bands(): [boolean, ModemBand[]];
            /**
             * Gets the list of generic families of access technologies supported by this
             * #MMModem without a firmware reload or reinitialization.
             * @returns A bitmask of #MMModemCapability flags.
             */
            get_current_capabilities(): ModemCapability;
            /**
             * Gets the list of modes specifying the access technologies (eg 2G/3G/4G)
             * the #MMModem is currently allowed to use when connecting to a network, as
             * well as the preferred one, if any.
             * @returns %TRUE if @allowed and @preferred are set, %FALSE otherwise.
             */
            get_current_modes(): [boolean, ModemMode, ModemMode];
            /**
             * Gets the physical modem device reference (ie, USB, PCI, PCMCIA device), which
             * may be dependent upon the operating system.
             *
             * <warning>The returned value is only valid until the property changes so it is
             * only safe to use this function on the thread where `self` was constructed. Use
             * mm_modem_dup_device() if on another thread.</warning>
             * @returns The device, or %NULL if none available. Do not free the returned value, it belongs to @self.
             */
            get_device(): string;
            /**
             * Gets a best-effort device identifier based on various device information like
             * model name, firmware revision, USB/PCI/PCMCIA IDs, and other properties.
             *
             * This ID is not guaranteed to be unique and may be shared between
             * identical devices with the same firmware, but is intended to be "unique
             * enough" for use as a casual device identifier for various user
             * experience operations.
             *
             * This is not the device's IMEI or ESN since those may not be available
             * before unlocking the device via a PIN.
             *
             * <warning>The returned value is only valid until the property changes so it is
             * only safe to use this function on the thread where `self` was constructed. Use
             * mm_modem_dup_device_identifier() if on another thread.</warning>
             * @returns The device identifier, or %NULL if none available. Do not free the returned value, it belongs to @self.
             */
            get_device_identifier(): string;
            /**
             * Gets the Operating System device drivers handling communication with the
             * modem hardware.
             *
             * <warning>The returned value is only valid until the property changes so it is
             * only safe to use this function on the thread where `self` was constructed. Use
             * mm_modem_dup_drivers() if on another thread.</warning>
             * @returns The drivers, or %NULL if none available. Do not free the returned value, it belongs to @self.
             */
            get_drivers(): string[];
            /**
             * Gets the identity of the #MMModem.
             *
             * This will be the IMEI number for GSM devices and the hex-format ESN/MEID
             * for CDMA devices.
             *
             * <warning>The returned value is only valid until the property changes so it is
             * only safe to use this function on the thread where `self` was constructed. Use
             * mm_modem_dup_equipment_identifier() if on another thread.</warning>
             * @returns The equipment identifier, or %NULL if none available. Do not free the returned value, it belongs to @self.
             */
            get_equipment_identifier(): string;
            /**
             * Gets the equipment hardware revision, as reported by this #MMModem.
             *
             * <warning>The returned value is only valid until the property changes so it is
             * only safe to use this function on the thread where `self` was constructed. Use
             * mm_modem_dup_hardware_revision() if on another thread.</warning>
             * @returns The equipment hardware revision, or %NULL if none available. Do not free the returned value, it belongs to @self.
             */
            get_hardware_revision(): string;
            /**
             * Gets the equipment manufacturer, as reported by this #MMModem.
             *
             * <warning>The returned value is only valid until the property changes so it is
             * only safe to use this function on the thread where `self` was constructed. Use
             * mm_modem_dup_manufacturer() if on another thread.</warning>
             * @returns The equipment manufacturer, or %NULL if none available. Do not free the returned value, it belongs to @self.
             */
            get_manufacturer(): string;
            /**
             * Gets the maximum number of active packet data bearers this #MMModem supports
             * without enabling multiplexing support.
             *
             * POTS and CDMA2000-only devices support one active bearer, while GSM/UMTS
             * and LTE/5GNR capable devices (including 3GPP+3GPP3 multimode devices) may support
             * one or more active bearers, depending on the amount of physical ports exposed
             * by the device.
             * @returns the maximum number of active packet data bearers.
             */
            get_max_active_bearers(): number;
            /**
             * Gets the maximum number of active packet data bearers this #MMModem supports
             * after enabling multiplexing support on one single network interface.
             * @returns the maximum number of active packet data bearers, or 0 if multiplexing is not supported.
             */
            get_max_active_multiplexed_bearers(): number;
            /**
             * Gets the maximum number of defined packet data bearers this #MMModem
             * supports.
             *
             * This is not the number of active/connected bearers the modem supports,
             * but simply the number of bearers that may be defined at any given time.
             * For example, POTS and CDMA2000-only devices support only one bearer,
             * while GSM/UMTS devices typically support three or more, and any
             * LTE-capable device (whether LTE-only, GSM/UMTS-capable, and/or
             * CDMA2000-capable) also typically support three or more.
             * @returns the maximum number of defined packet data bearers.
             */
            get_max_bearers(): number;
            /**
             * Gets the equipment model, as reported by this #MMModem.
             *
             * <warning>The returned value is only valid until the property changes so it is
             * only safe to use this function on the thread where `self` was constructed. Use
             * mm_modem_dup_model() if on another thread.</warning>
             * @returns The equipment model, or %NULL if none available. Do not free the returned value, it belongs to @self.
             */
            get_model(): string;
            /**
             * Gets the physical modem device path (ie, USB, PCI, PCMCIA device), which
             * may be dependent upon the operating system.
             *
             * <warning>The returned value is only valid until the property changes so it is
             * only safe to use this function on the thread where `self` was constructed. Use
             * mm_modem_dup_physdev() if on another thread.</warning>
             * @returns The physdev path, or %NULL if none available. Do not free the returned value, it belongs to @self.
             */
            get_physdev(): string;
            /**
             * Gets the name of the plugin handling this #MMModem.
             *
             * <warning>The returned value is only valid until the property changes so it is
             * only safe to use this function on the thread where `self` was constructed. Use
             * mm_modem_dup_plugin() if on another thread.</warning>
             * @returns The name of the plugin, or %NULL if none available. Do not free the returned value, it belongs to @self.
             */
            get_plugin(): string;
            /**
             * Gets the list of ports in the modem.
             * @returns %TRUE if @ports and @n_ports are set, %FALSE otherwise.
             */
            get_ports(): [boolean, ModemPortInfo[]];
            /**
             * Gets the power state of the #MMModem.
             * @returns A #MMModemPowerState value.
             */
            get_power_state(): ModemPowerState;
            /**
             * Gets the name of the primary port controlling this #MMModem.
             *
             * <warning>The returned value is only valid until the property changes so it is
             * only safe to use this function on the thread where `self` was constructed. Use
             * mm_modem_dup_primary_port() if on another thread.</warning>
             * @returns The name of the primary port. Do not free the returned value, it belongs to @self.
             */
            get_primary_port(): string;
            /**
             * Gets the SIM slot number of the primary active SIM.
             * @returns slot number, in the [1,N] range.
             */
            get_primary_sim_slot(): number;
            /**
             * Gets the equipment revision, as reported by this #MMModem.
             *
             * <warning>The returned value is only valid until the property changes so it is
             * only safe to use this function on the thread where `self` was constructed. Use
             * mm_modem_dup_revision() if on another thread.</warning>
             * @returns The equipment revision, or %NULL if none available. Do not free the returned value, it belongs to @self.
             */
            get_revision(): string;
            /**
             * Gets the signal quality value in percent (0 - 100) of the dominant access
             * technology the #MMModem is using to communicate with the network.
             *
             * Always 0 for POTS devices.
             * @returns The signal quality.
             */
            get_signal_quality(): [number, boolean];
            /**
             * Asynchronously gets the #MMSim object managed by this #MMModem.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_get_sim_finish() to get the result of the operation.
             *
             * See mm_modem_get_sim_sync() for the synchronous, blocking version of this
             * method.
             * @param cancellable A #GCancellable or %NULL.
             */
            get_sim(cancellable?: Gio.Cancellable | null): Promise<Sim>;
            /**
             * Asynchronously gets the #MMSim object managed by this #MMModem.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_get_sim_finish() to get the result of the operation.
             *
             * See mm_modem_get_sim_sync() for the synchronous, blocking version of this
             * method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            get_sim(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously gets the #MMSim object managed by this #MMModem.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_get_sim_finish() to get the result of the operation.
             *
             * See mm_modem_get_sim_sync() for the synchronous, blocking version of this
             * method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            get_sim(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<Sim> | void;
            /**
             * Finishes an operation started with mm_modem_get_sim().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_get_sim().
             * @returns a #MMSim or #NULL if @error is set. The returned value should be freed with g_object_unref().
             */
            get_sim_finish(res: Gio.AsyncResult): Sim;
            /**
             * Gets the DBus paths of the #MMSim objects available in the different SIM
             * slots handled in this #MMModem. If a given SIM slot at a given index doesn't
             * have a SIM card available, an empty object path will be given. This list
             * includes the currently active SIM object path.
             *
             * <warning>The returned value is only valid until the property changes so it is
             * only safe to use this function on the thread where `self` was constructed. Use
             * mm_modem_dup_sim_slot_paths() if on another thread.</warning>
             * @returns The DBus paths of the #MMSim objects handled in this #MMModem, or %NULL if none available. Do not free the returned value, it belongs to @self.
             */
            get_sim_slot_paths(): string[];
            /**
             * Synchronously gets the #MMSim object managed by this #MMModem.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_get_sim() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns a #MMSim or #NULL if @error is set. The returned value should be freed with g_object_unref().
             */
            get_sim_sync(cancellable?: Gio.Cancellable | null): Sim;
            /**
             * Gets the overall state of the #MMModem.
             * @returns A #MMModemState value.
             */
            get_state(): ModemState;
            /**
             * Gets the reason specifying why the modem is in #MM_MODEM_STATE_FAILED state.
             * @returns A #MMModemStateFailedReason value.
             */
            get_state_failed_reason(): ModemStateFailedReason;
            /**
             * Gets the list of radio frequency and technology bands supported by the
             * #MMModem.
             *
             * For POTS devices, only #MM_MODEM_BAND_ANY will be returned in `bands`.
             * @returns %TRUE if @bands and @n_bands are set, %FALSE otherwise.
             */
            get_supported_bands(): [boolean, ModemBand[]];
            /**
             * Gets the list of combinations of generic families of access technologies
             * supported by this #MMModem.
             * @returns %TRUE if @capabilities and @n_capabilities are set, %FALSE otherwise.
             */
            get_supported_capabilities(): [boolean, ModemCapability[]];
            /**
             * Gets the list of supported IP families.
             * @returns A bitmask of #MMBearerIpFamily values.
             */
            get_supported_ip_families(): BearerIpFamily;
            /**
             * Gets the list of supported mode combinations.
             * @returns %TRUE if @modes and @n_modes are set, %FALSE otherwise.
             */
            get_supported_modes(): [boolean, ModemModeCombination[]];
            /**
             * Gets current lock state of the #MMModem.
             * @returns A #MMModemLock value, specifying the current lock state.
             */
            get_unlock_required(): ModemLock;
            /**
             * Gets a #MMUnlockRetries object, which provides, for each
             * <link linkend="MMModemLock">MMModemLock</link> handled by the modem, the
             * number of PIN tries remaining before the code becomes blocked (requiring a
             * PUK) or permanently blocked.
             *
             * <warning>The values reported by `self` are not updated when the values in the
             * interface change. Instead, the client is expected to call
             * mm_modem_get_unlock_retries() again to get a new #MMUnlockRetries with the
             * new values.</warning>
             * @returns A #MMUnlockRetries that must be freed with g_object_unref() or %NULL if unknown.
             */
            get_unlock_retries(): UnlockRetries;
            /**
             * Asynchronously lists the packet data bearers in the #MMModem.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_list_bearers_finish() to get the result of the operation.
             *
             * See mm_modem_list_bearers_sync() for the synchronous, blocking version of
             * this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            list_bearers(cancellable?: Gio.Cancellable | null): Promise<Bearer[]>;
            /**
             * Asynchronously lists the packet data bearers in the #MMModem.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_list_bearers_finish() to get the result of the operation.
             *
             * See mm_modem_list_bearers_sync() for the synchronous, blocking version of
             * this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            list_bearers(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously lists the packet data bearers in the #MMModem.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_list_bearers_finish() to get the result of the operation.
             *
             * See mm_modem_list_bearers_sync() for the synchronous, blocking version of
             * this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            list_bearers(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<Bearer[]> | void;
            /**
             * Finishes an operation started with mm_modem_list_bearers().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_list_bearers().
             * @returns The list of #MMBearer objects, or %NULL if either none found or if @error is set.
             */
            list_bearers_finish(res: Gio.AsyncResult): Bearer[];
            /**
             * Synchronously lists the packet data bearers in the #MMModem.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_list_bearers() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns The list of #MMBearer objects, or %NULL if either none found or if @error is set.
             */
            list_bearers_sync(cancellable?: Gio.Cancellable | null): Bearer[];
            /**
             * Asynchronously lists the SIM slots available in the #MMModem.
             *
             * The returned array contains one element per slot available in the system;
             * a #MMSim in each of the slots that contains a valid SIM card or %NULL if
             * no SIM card is found.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_list_sim_slots_finish() to get the result of the operation.
             *
             * See mm_modem_list_sim_slots_sync() for the synchronous, blocking version of
             * this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            list_sim_slots(cancellable?: Gio.Cancellable | null): Promise<Sim[]>;
            /**
             * Asynchronously lists the SIM slots available in the #MMModem.
             *
             * The returned array contains one element per slot available in the system;
             * a #MMSim in each of the slots that contains a valid SIM card or %NULL if
             * no SIM card is found.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_list_sim_slots_finish() to get the result of the operation.
             *
             * See mm_modem_list_sim_slots_sync() for the synchronous, blocking version of
             * this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            list_sim_slots(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously lists the SIM slots available in the #MMModem.
             *
             * The returned array contains one element per slot available in the system;
             * a #MMSim in each of the slots that contains a valid SIM card or %NULL if
             * no SIM card is found.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_list_sim_slots_finish() to get the result of the operation.
             *
             * See mm_modem_list_sim_slots_sync() for the synchronous, blocking version of
             * this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            list_sim_slots(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<Sim[]> | void;
            /**
             * Finishes an operation started with mm_modem_list_sim_slots().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_list_sim_slots().
             * @returns The array of #MMSim objects, or %NULL if @error is set.
             */
            list_sim_slots_finish(res: Gio.AsyncResult): Sim[];
            /**
             * Synchronously lists the SIM slots available in the #MMModem.
             *
             * The returned array contains one element per slot available in the system;
             * a #MMSim in each of the slots that contains a valid SIM card or %NULL if
             * no SIM card is found.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_list_sim_slots() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns The array of #MMSim objects, or %NULL if @error is set.
             */
            list_sim_slots_sync(cancellable?: Gio.Cancellable | null): Sim[];
            /**
             * Gets the list of radio frequency and technology bands the #MMModem is
             * currently using when connecting to a network.
             *
             * For POTS devices, only the #MM_MODEM_BAND_ANY band is supported.
             * @returns %TRUE if @bands and @n_bands are set, %FALSE otherwise.
             */
            peek_current_bands(): [boolean, ModemBand[]];
            /**
             * Gets the list of ports in the modem.
             * @returns %TRUE if @ports and @n_ports are set, %FALSE otherwise.
             */
            peek_ports(): [boolean, ModemPortInfo[]];
            /**
             * Gets the list of radio frequency and technology bands supported by the
             * #MMModem.
             *
             * For POTS devices, only #MM_MODEM_BAND_ANY will be returned in `bands`.
             * @returns %TRUE if @bands and @n_bands are set, %FALSE otherwise.
             */
            peek_supported_bands(): [boolean, ModemBand[]];
            /**
             * Gets the list of combinations of generic families of access technologies
             * supported by this #MMModem.
             * @returns %TRUE if @capabilities and @n_capabilities are set, %FALSE otherwise.
             */
            peek_supported_capabilities(): [boolean, ModemCapability[]];
            /**
             * Gets the list of supported mode combinations.
             * @returns %TRUE if @modes and @n_modes are set, %FALSE otherwise.
             */
            peek_supported_modes(): [boolean, ModemModeCombination[]];
            /**
             * Gets a #MMUnlockRetries object, which provides, for each
             * <link linkend="MMModemLock">MMModemLock</link> handled by the modem, the
             * number of PIN tries remaining before the code becomes blocked (requiring a
             * PUK) or permanently blocked.
             *
             * <warning>The returned value is only valid until the property changes so it is
             * only safe to use this function on the thread where `self` was constructed. Use
             * mm_modem_get_unlock_retries() if on another thread.</warning>
             * @returns A #MMUnlockRetries. Do not free the returned value, it belongs to @self.
             */
            peek_unlock_retries(): UnlockRetries;
            /**
             * Asynchronously clears non-persistent configuration and state, and returns the
             * device to a newly-powered-on state.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_reset_finish() to get the result of the operation.
             *
             * See mm_modem_reset_sync() for the synchronous, blocking version of this
             * method.
             * @param cancellable A #GCancellable or %NULL.
             */
            reset(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously clears non-persistent configuration and state, and returns the
             * device to a newly-powered-on state.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_reset_finish() to get the result of the operation.
             *
             * See mm_modem_reset_sync() for the synchronous, blocking version of this
             * method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            reset(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously clears non-persistent configuration and state, and returns the
             * device to a newly-powered-on state.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_reset_finish() to get the result of the operation.
             *
             * See mm_modem_reset_sync() for the synchronous, blocking version of this
             * method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            reset(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_modem_reset().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_reset().
             * @returns %TRUE if the reset was successful, %FALSE if @error is set.
             */
            reset_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously clears non-persistent configuration and state, and returns the
             * device to a newly-powered-on state.
             *
             * The calling thread is blocked until a reply is received. See mm_modem_reset()
             * for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the reset was successful, %FALSE if @error is set.
             */
            reset_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously sets the radio frequency and technology bands the device is
             * currently allowed to use when connecting to a network.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_set_current_bands_finish() to get the result of the operation.
             *
             * See mm_modem_set_current_bands_sync() for the synchronous, blocking version
             * of this method.
             * @param bands An array of #MMModemBand values specifying which bands are allowed.
             * @param n_bands Number of elements in @bands.
             * @param cancellable A #GCancellable or %NULL.
             */
            set_current_bands(
                bands: ModemBand | null,
                n_bands: number,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronously sets the radio frequency and technology bands the device is
             * currently allowed to use when connecting to a network.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_set_current_bands_finish() to get the result of the operation.
             *
             * See mm_modem_set_current_bands_sync() for the synchronous, blocking version
             * of this method.
             * @param bands An array of #MMModemBand values specifying which bands are allowed.
             * @param n_bands Number of elements in @bands.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            set_current_bands(
                bands: ModemBand | null,
                n_bands: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously sets the radio frequency and technology bands the device is
             * currently allowed to use when connecting to a network.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_set_current_bands_finish() to get the result of the operation.
             *
             * See mm_modem_set_current_bands_sync() for the synchronous, blocking version
             * of this method.
             * @param bands An array of #MMModemBand values specifying which bands are allowed.
             * @param n_bands Number of elements in @bands.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            set_current_bands(
                bands: ModemBand | null,
                n_bands: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_modem_set_current_bands().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_set_current_bands().
             * @returns %TRUE if the bands were successfully set, %FALSE if @error is set.
             */
            set_current_bands_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously sets the radio frequency and technology bands the device is
             * currently allowed to use when connecting to a network.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_set_current_bands() for the asynchronous version of this method.
             * @param bands An array of #MMModemBand values specifying which bands are allowed.
             * @param n_bands Number of elements in @bands.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the bands were successfully set, %FALSE if @error is set.
             */
            set_current_bands_sync(
                bands: ModemBand | null,
                n_bands: number,
                cancellable?: Gio.Cancellable | null,
            ): boolean;
            /**
             * Asynchronously sets the capabilities of the device. A restart of the modem
             * may be required.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_set_current_capabilities_finish() to get the result of the
             * operation.
             *
             * See mm_modem_set_current_capabilities_sync() for the synchronous, blocking
             * version of this method.
             * @param capabilities A #MMModemCapability mask.
             * @param cancellable A #GCancellable or %NULL.
             */
            set_current_capabilities(
                capabilities: ModemCapability | null,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronously sets the capabilities of the device. A restart of the modem
             * may be required.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_set_current_capabilities_finish() to get the result of the
             * operation.
             *
             * See mm_modem_set_current_capabilities_sync() for the synchronous, blocking
             * version of this method.
             * @param capabilities A #MMModemCapability mask.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            set_current_capabilities(
                capabilities: ModemCapability | null,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously sets the capabilities of the device. A restart of the modem
             * may be required.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_set_current_capabilities_finish() to get the result of the
             * operation.
             *
             * See mm_modem_set_current_capabilities_sync() for the synchronous, blocking
             * version of this method.
             * @param capabilities A #MMModemCapability mask.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            set_current_capabilities(
                capabilities: ModemCapability | null,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_modem_set_current_capabilities().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_set_current_capabilities().
             * @returns %TRUE if the capabilities were successfully set, %FALSE if @error is set.
             */
            set_current_capabilities_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously sets the capabilities of the device. A restart of the modem may
             * be required.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_set_current_capabilities() for the asynchronous version of this
             * method.
             * @param capabilities A #MMModemCapability mask.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the capabilities were successfully set, %FALSE if @error is set.
             */
            set_current_capabilities_sync(
                capabilities: ModemCapability | null,
                cancellable?: Gio.Cancellable | null,
            ): boolean;
            /**
             * Asynchronously sets the access technologies (e.g. 2G/3G/4G preference) the
             * device is currently allowed to use when connecting to a network.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_set_current_modes_finish() to get the result of the operation.
             *
             * See mm_modem_set_current_modes_sync() for the synchronous, blocking version
             * of this method.
             * @param modes Mask of #MMModemMode values specifying which modes are allowed.
             * @param preferred A #MMModemMode value specifying which of the modes given in  @modes is the preferred one, or #MM_MODEM_MODE_NONE if none.
             * @param cancellable A #GCancellable or %NULL.
             */
            set_current_modes(
                modes: ModemMode | null,
                preferred: ModemMode | null,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronously sets the access technologies (e.g. 2G/3G/4G preference) the
             * device is currently allowed to use when connecting to a network.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_set_current_modes_finish() to get the result of the operation.
             *
             * See mm_modem_set_current_modes_sync() for the synchronous, blocking version
             * of this method.
             * @param modes Mask of #MMModemMode values specifying which modes are allowed.
             * @param preferred A #MMModemMode value specifying which of the modes given in  @modes is the preferred one, or #MM_MODEM_MODE_NONE if none.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            set_current_modes(
                modes: ModemMode | null,
                preferred: ModemMode | null,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously sets the access technologies (e.g. 2G/3G/4G preference) the
             * device is currently allowed to use when connecting to a network.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_set_current_modes_finish() to get the result of the operation.
             *
             * See mm_modem_set_current_modes_sync() for the synchronous, blocking version
             * of this method.
             * @param modes Mask of #MMModemMode values specifying which modes are allowed.
             * @param preferred A #MMModemMode value specifying which of the modes given in  @modes is the preferred one, or #MM_MODEM_MODE_NONE if none.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            set_current_modes(
                modes: ModemMode | null,
                preferred: ModemMode | null,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_modem_set_current_modes().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_set_current_modes().
             * @returns %TRUE if the allowed modes were successfully set, %FALSE if @error is set.
             */
            set_current_modes_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously sets the access technologies (e.g. 2G/3G/4G preference) the
             * device is currently allowed to use when connecting to a network.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_set_current_modes() for the asynchronous version of this method.
             * @param modes Mask of #MMModemMode values specifying which modes are allowed.
             * @param preferred A #MMModemMode value specifying which of the modes given in  @modes is the preferred one, or #MM_MODEM_MODE_NONE if none.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the allowed modes were successfully set, %FALSE if @error is set.
             */
            set_current_modes_sync(
                modes: ModemMode | null,
                preferred: ModemMode | null,
                cancellable?: Gio.Cancellable | null,
            ): boolean;
            /**
             * Asynchronously sets the power state of the device. This method can only be
             * used while the modem is in %MM_MODEM_STATE_DISABLED state.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_set_power_state_finish() to get the result of the operation.
             *
             * See mm_modem_set_power_state_sync() for the synchronous, blocking version of
             * this method.
             * @param state Either %MM_MODEM_POWER_STATE_LOW or %MM_MODEM_POWER_STATE_ON. Every  other #MMModemPowerState value is not allowed.
             * @param cancellable A #GCancellable or %NULL.
             */
            set_power_state(state: ModemPowerState | null, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously sets the power state of the device. This method can only be
             * used while the modem is in %MM_MODEM_STATE_DISABLED state.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_set_power_state_finish() to get the result of the operation.
             *
             * See mm_modem_set_power_state_sync() for the synchronous, blocking version of
             * this method.
             * @param state Either %MM_MODEM_POWER_STATE_LOW or %MM_MODEM_POWER_STATE_ON. Every  other #MMModemPowerState value is not allowed.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            set_power_state(
                state: ModemPowerState | null,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously sets the power state of the device. This method can only be
             * used while the modem is in %MM_MODEM_STATE_DISABLED state.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_set_power_state_finish() to get the result of the operation.
             *
             * See mm_modem_set_power_state_sync() for the synchronous, blocking version of
             * this method.
             * @param state Either %MM_MODEM_POWER_STATE_LOW or %MM_MODEM_POWER_STATE_ON. Every  other #MMModemPowerState value is not allowed.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            set_power_state(
                state: ModemPowerState | null,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_modem_set_power_state().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_set_power_state().
             * @returns %TRUE if the power state was successfully set, %FALSE if @error is set.
             */
            set_power_state_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously sets the power state of the device. This method can only be
             * used while the modem is in %MM_MODEM_STATE_DISABLED state.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_set_power_state() for the asynchronous version of this method.
             * @param state Either %MM_MODEM_POWER_STATE_LOW or %MM_MODEM_POWER_STATE_ON. Every  other #MMModemPowerState value is not allowed.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the power state was successfully set, %FALSE if @error is set.
             */
            set_power_state_sync(state: ModemPowerState | null, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously requests to select which SIM slot to be considered as primary.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_set_primary_sim_slot_finish() to get the result of the operation.
             *
             * See mm_modem_set_primary_sim_slot_sync() for the synchronous, blocking version of
             * this method.
             * @param sim_slot SIM slot number.
             * @param cancellable A #GCancellable or %NULL.
             */
            set_primary_sim_slot(sim_slot: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously requests to select which SIM slot to be considered as primary.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_set_primary_sim_slot_finish() to get the result of the operation.
             *
             * See mm_modem_set_primary_sim_slot_sync() for the synchronous, blocking version of
             * this method.
             * @param sim_slot SIM slot number.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            set_primary_sim_slot(
                sim_slot: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously requests to select which SIM slot to be considered as primary.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_set_primary_sim_slot_finish() to get the result of the operation.
             *
             * See mm_modem_set_primary_sim_slot_sync() for the synchronous, blocking version of
             * this method.
             * @param sim_slot SIM slot number.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            set_primary_sim_slot(
                sim_slot: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_modem_set_primary_sim_slot().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_set_primary_sim_slot().
             * @returns %TRUE if the SIM slot switch has been successfully requested, %FALSE if @error is set.
             */
            set_primary_sim_slot_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously requests to select which SIM slot to be considered as primary.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_set_primary_sim_slot() for the asynchronous version of this method.
             * @param sim_slot SIM slot number.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the SIM slot switch has been successfully requested, %FALSE if @error is set.
             */
            set_primary_sim_slot_sync(sim_slot: number, cancellable?: Gio.Cancellable | null): boolean;

            // Inherited properties
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.AccessTechnologies">"AccessTechnologies"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get access_technologies(): number;
            set access_technologies(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.AccessTechnologies">"AccessTechnologies"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get accessTechnologies(): number;
            set accessTechnologies(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.Bearers">"Bearers"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get bearers(): string[];
            set bearers(val: string[]);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.CarrierConfiguration">"CarrierConfiguration"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get carrier_configuration(): string;
            set carrier_configuration(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.CarrierConfiguration">"CarrierConfiguration"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get carrierConfiguration(): string;
            set carrierConfiguration(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.CarrierConfigurationRevision">"CarrierConfigurationRevision"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get carrier_configuration_revision(): string;
            set carrier_configuration_revision(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.CarrierConfigurationRevision">"CarrierConfigurationRevision"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get carrierConfigurationRevision(): string;
            set carrierConfigurationRevision(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.CurrentBands">"CurrentBands"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get current_bands(): GLib.Variant;
            set current_bands(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.CurrentBands">"CurrentBands"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get currentBands(): GLib.Variant;
            set currentBands(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.CurrentCapabilities">"CurrentCapabilities"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get current_capabilities(): number;
            set current_capabilities(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.CurrentCapabilities">"CurrentCapabilities"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get currentCapabilities(): number;
            set currentCapabilities(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.CurrentModes">"CurrentModes"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get current_modes(): GLib.Variant;
            set current_modes(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.CurrentModes">"CurrentModes"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get currentModes(): GLib.Variant;
            set currentModes(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.Device">"Device"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get device(): string;
            set device(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.DeviceIdentifier">"DeviceIdentifier"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get device_identifier(): string;
            set device_identifier(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.DeviceIdentifier">"DeviceIdentifier"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get deviceIdentifier(): string;
            set deviceIdentifier(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.Drivers">"Drivers"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get drivers(): string[];
            set drivers(val: string[]);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.EquipmentIdentifier">"EquipmentIdentifier"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get equipment_identifier(): string;
            set equipment_identifier(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.EquipmentIdentifier">"EquipmentIdentifier"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get equipmentIdentifier(): string;
            set equipmentIdentifier(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.HardwareRevision">"HardwareRevision"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get hardware_revision(): string;
            set hardware_revision(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.HardwareRevision">"HardwareRevision"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get hardwareRevision(): string;
            set hardwareRevision(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.Manufacturer">"Manufacturer"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get manufacturer(): string;
            set manufacturer(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.MaxActiveBearers">"MaxActiveBearers"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get max_active_bearers(): number;
            set max_active_bearers(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.MaxActiveBearers">"MaxActiveBearers"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get maxActiveBearers(): number;
            set maxActiveBearers(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.MaxActiveMultiplexedBearers">"MaxActiveMultiplexedBearers"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get max_active_multiplexed_bearers(): number;
            set max_active_multiplexed_bearers(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.MaxActiveMultiplexedBearers">"MaxActiveMultiplexedBearers"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get maxActiveMultiplexedBearers(): number;
            set maxActiveMultiplexedBearers(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.MaxBearers">"MaxBearers"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get max_bearers(): number;
            set max_bearers(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.MaxBearers">"MaxBearers"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get maxBearers(): number;
            set maxBearers(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.Model">"Model"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get model(): string;
            set model(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.OwnNumbers">"OwnNumbers"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get own_numbers(): string[];
            set own_numbers(val: string[]);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.OwnNumbers">"OwnNumbers"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get ownNumbers(): string[];
            set ownNumbers(val: string[]);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.Physdev">"Physdev"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get physdev(): string;
            set physdev(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.Plugin">"Plugin"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get plugin(): string;
            set plugin(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.Ports">"Ports"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get ports(): GLib.Variant;
            set ports(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.PowerState">"PowerState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get power_state(): number;
            set power_state(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.PowerState">"PowerState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get powerState(): number;
            set powerState(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.PrimaryPort">"PrimaryPort"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get primary_port(): string;
            set primary_port(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.PrimaryPort">"PrimaryPort"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get primaryPort(): string;
            set primaryPort(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.PrimarySimSlot">"PrimarySimSlot"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get primary_sim_slot(): number;
            set primary_sim_slot(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.PrimarySimSlot">"PrimarySimSlot"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get primarySimSlot(): number;
            set primarySimSlot(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.Revision">"Revision"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get revision(): string;
            set revision(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.SignalQuality">"SignalQuality"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get signal_quality(): GLib.Variant;
            set signal_quality(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.SignalQuality">"SignalQuality"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get signalQuality(): GLib.Variant;
            set signalQuality(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.Sim">"Sim"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get sim(): string;
            set sim(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.SimSlots">"SimSlots"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get sim_slots(): string[];
            set sim_slots(val: string[]);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.SimSlots">"SimSlots"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get simSlots(): string[];
            set simSlots(val: string[]);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.State">"State"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get state(): number;
            set state(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.StateFailedReason">"StateFailedReason"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get state_failed_reason(): number;
            set state_failed_reason(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.StateFailedReason">"StateFailedReason"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get stateFailedReason(): number;
            set stateFailedReason(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.SupportedBands">"SupportedBands"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get supported_bands(): GLib.Variant;
            set supported_bands(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.SupportedBands">"SupportedBands"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get supportedBands(): GLib.Variant;
            set supportedBands(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.SupportedCapabilities">"SupportedCapabilities"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get supported_capabilities(): GLib.Variant;
            set supported_capabilities(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.SupportedCapabilities">"SupportedCapabilities"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get supportedCapabilities(): GLib.Variant;
            set supportedCapabilities(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.SupportedIpFamilies">"SupportedIpFamilies"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get supported_ip_families(): number;
            set supported_ip_families(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.SupportedIpFamilies">"SupportedIpFamilies"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get supportedIpFamilies(): number;
            set supportedIpFamilies(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.SupportedModes">"SupportedModes"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get supported_modes(): GLib.Variant;
            set supported_modes(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.SupportedModes">"SupportedModes"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get supportedModes(): GLib.Variant;
            set supportedModes(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.UnlockRequired">"UnlockRequired"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get unlock_required(): number;
            set unlock_required(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.UnlockRequired">"UnlockRequired"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get unlockRequired(): number;
            set unlockRequired(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.UnlockRetries">"UnlockRetries"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get unlock_retries(): GLib.Variant;
            set unlock_retries(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.UnlockRetries">"UnlockRetries"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get unlockRetries(): GLib.Variant;
            set unlockRetries(val: GLib.Variant);

            // Inherited methods
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            init_async(io_priority: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             * @returns %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present.
             */
            init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Finishes the async construction for the various g_async_initable_new
             * calls, returning the created object or %NULL on error.
             * @param res the #GAsyncResult from the callback
             * @returns a newly created #GObject,      or %NULL on error. Free with g_object_unref().
             */
            new_finish(res: Gio.AsyncResult): Modem;
            // Conflicted with ModemManager.GdbusModemProxy.new_finish
            new_finish(...args: never[]): any;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            vfunc_init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             */
            vfunc_init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.Command">Command()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_command_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_command_sync() for the synchronous, blocking version of this method.
             * @param arg_cmd Argument to pass with the method invocation.
             * @param arg_timeout Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_command(arg_cmd: string, arg_timeout: number, cancellable?: Gio.Cancellable | null): Promise<string>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.Command">Command()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_command_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_command_sync() for the synchronous, blocking version of this method.
             * @param arg_cmd Argument to pass with the method invocation.
             * @param arg_timeout Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_command(
                arg_cmd: string,
                arg_timeout: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.Command">Command()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_command_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_command_sync() for the synchronous, blocking version of this method.
             * @param arg_cmd Argument to pass with the method invocation.
             * @param arg_timeout Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_command(
                arg_cmd: string,
                arg_timeout: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<string> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_call_command().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_call_command().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_command_finish(res: Gio.AsyncResult): [boolean, string];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.Command">Command()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_call_command() for the asynchronous version of this method.
             * @param arg_cmd Argument to pass with the method invocation.
             * @param arg_timeout Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_command_sync(
                arg_cmd: string,
                arg_timeout: number,
                cancellable?: Gio.Cancellable | null,
            ): [boolean, string];
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.CreateBearer">CreateBearer()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_create_bearer_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_create_bearer_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_create_bearer(arg_properties: GLib.Variant, cancellable?: Gio.Cancellable | null): Promise<string>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.CreateBearer">CreateBearer()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_create_bearer_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_create_bearer_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_create_bearer(
                arg_properties: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.CreateBearer">CreateBearer()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_create_bearer_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_create_bearer_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_create_bearer(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<string> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_call_create_bearer().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_call_create_bearer().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_create_bearer_finish(res: Gio.AsyncResult): [boolean, string];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.CreateBearer">CreateBearer()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_call_create_bearer() for the asynchronous version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_create_bearer_sync(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
            ): [boolean, string];
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.DeleteBearer">DeleteBearer()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_delete_bearer_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_delete_bearer_sync() for the synchronous, blocking version of this method.
             * @param arg_bearer Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_delete_bearer(arg_bearer: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.DeleteBearer">DeleteBearer()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_delete_bearer_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_delete_bearer_sync() for the synchronous, blocking version of this method.
             * @param arg_bearer Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_delete_bearer(
                arg_bearer: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.DeleteBearer">DeleteBearer()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_delete_bearer_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_delete_bearer_sync() for the synchronous, blocking version of this method.
             * @param arg_bearer Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_delete_bearer(
                arg_bearer: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_call_delete_bearer().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_call_delete_bearer().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_delete_bearer_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.DeleteBearer">DeleteBearer()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_call_delete_bearer() for the asynchronous version of this method.
             * @param arg_bearer Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_delete_bearer_sync(arg_bearer: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.Enable">Enable()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_enable_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_enable_sync() for the synchronous, blocking version of this method.
             * @param arg_enable Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_enable(arg_enable: boolean, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.Enable">Enable()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_enable_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_enable_sync() for the synchronous, blocking version of this method.
             * @param arg_enable Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_enable(
                arg_enable: boolean,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.Enable">Enable()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_enable_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_enable_sync() for the synchronous, blocking version of this method.
             * @param arg_enable Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_enable(
                arg_enable: boolean,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_call_enable().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_call_enable().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_enable_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.Enable">Enable()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_call_enable() for the asynchronous version of this method.
             * @param arg_enable Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_enable_sync(arg_enable: boolean, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.FactoryReset">FactoryReset()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_factory_reset_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_factory_reset_sync() for the synchronous, blocking version of this method.
             * @param arg_code Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_factory_reset(arg_code: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.FactoryReset">FactoryReset()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_factory_reset_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_factory_reset_sync() for the synchronous, blocking version of this method.
             * @param arg_code Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_factory_reset(
                arg_code: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.FactoryReset">FactoryReset()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_factory_reset_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_factory_reset_sync() for the synchronous, blocking version of this method.
             * @param arg_code Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_factory_reset(
                arg_code: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_call_factory_reset().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_call_factory_reset().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_factory_reset_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.FactoryReset">FactoryReset()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_call_factory_reset() for the asynchronous version of this method.
             * @param arg_code Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_factory_reset_sync(arg_code: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.GetCellInfo">GetCellInfo()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_get_cell_info_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_get_cell_info_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_get_cell_info(cancellable?: Gio.Cancellable | null): Promise<GLib.Variant | null>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.GetCellInfo">GetCellInfo()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_get_cell_info_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_get_cell_info_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_get_cell_info(
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.GetCellInfo">GetCellInfo()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_get_cell_info_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_get_cell_info_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_get_cell_info(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<GLib.Variant | null> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_call_get_cell_info().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_call_get_cell_info().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_get_cell_info_finish(res: Gio.AsyncResult): [boolean, GLib.Variant | null];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.GetCellInfo">GetCellInfo()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_call_get_cell_info() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_get_cell_info_sync(cancellable?: Gio.Cancellable | null): [boolean, GLib.Variant | null];
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.ListBearers">ListBearers()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_list_bearers_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_list_bearers_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_list_bearers(cancellable?: Gio.Cancellable | null): Promise<string[] | null>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.ListBearers">ListBearers()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_list_bearers_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_list_bearers_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_list_bearers(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.ListBearers">ListBearers()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_list_bearers_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_list_bearers_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_list_bearers(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<string[] | null> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_call_list_bearers().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_call_list_bearers().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_list_bearers_finish(res: Gio.AsyncResult): [boolean, string[] | null];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.ListBearers">ListBearers()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_call_list_bearers() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_list_bearers_sync(cancellable?: Gio.Cancellable | null): [boolean, string[] | null];
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.Reset">Reset()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_reset_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_reset_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_reset(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.Reset">Reset()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_reset_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_reset_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_reset(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.Reset">Reset()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_reset_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_reset_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_reset(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_call_reset().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_call_reset().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_reset_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.Reset">Reset()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_call_reset() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_reset_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetCurrentBands">SetCurrentBands()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_set_current_bands_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_set_current_bands_sync() for the synchronous, blocking version of this method.
             * @param arg_bands Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set_current_bands(arg_bands: GLib.Variant, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetCurrentBands">SetCurrentBands()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_set_current_bands_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_set_current_bands_sync() for the synchronous, blocking version of this method.
             * @param arg_bands Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_current_bands(
                arg_bands: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetCurrentBands">SetCurrentBands()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_set_current_bands_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_set_current_bands_sync() for the synchronous, blocking version of this method.
             * @param arg_bands Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_current_bands(
                arg_bands: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_call_set_current_bands().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_call_set_current_bands().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_current_bands_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetCurrentBands">SetCurrentBands()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_call_set_current_bands() for the asynchronous version of this method.
             * @param arg_bands Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_current_bands_sync(arg_bands: GLib.Variant, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetCurrentCapabilities">SetCurrentCapabilities()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_set_current_capabilities_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_set_current_capabilities_sync() for the synchronous, blocking version of this method.
             * @param arg_capabilities Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set_current_capabilities(
                arg_capabilities: number,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetCurrentCapabilities">SetCurrentCapabilities()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_set_current_capabilities_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_set_current_capabilities_sync() for the synchronous, blocking version of this method.
             * @param arg_capabilities Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_current_capabilities(
                arg_capabilities: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetCurrentCapabilities">SetCurrentCapabilities()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_set_current_capabilities_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_set_current_capabilities_sync() for the synchronous, blocking version of this method.
             * @param arg_capabilities Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_current_capabilities(
                arg_capabilities: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_call_set_current_capabilities().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_call_set_current_capabilities().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_current_capabilities_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetCurrentCapabilities">SetCurrentCapabilities()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_call_set_current_capabilities() for the asynchronous version of this method.
             * @param arg_capabilities Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_current_capabilities_sync(arg_capabilities: number, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetCurrentModes">SetCurrentModes()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_set_current_modes_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_set_current_modes_sync() for the synchronous, blocking version of this method.
             * @param arg_modes Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set_current_modes(arg_modes: GLib.Variant, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetCurrentModes">SetCurrentModes()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_set_current_modes_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_set_current_modes_sync() for the synchronous, blocking version of this method.
             * @param arg_modes Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_current_modes(
                arg_modes: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetCurrentModes">SetCurrentModes()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_set_current_modes_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_set_current_modes_sync() for the synchronous, blocking version of this method.
             * @param arg_modes Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_current_modes(
                arg_modes: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_call_set_current_modes().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_call_set_current_modes().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_current_modes_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetCurrentModes">SetCurrentModes()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_call_set_current_modes() for the asynchronous version of this method.
             * @param arg_modes Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_current_modes_sync(arg_modes: GLib.Variant, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetPowerState">SetPowerState()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_set_power_state_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_set_power_state_sync() for the synchronous, blocking version of this method.
             * @param arg_state Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set_power_state(arg_state: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetPowerState">SetPowerState()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_set_power_state_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_set_power_state_sync() for the synchronous, blocking version of this method.
             * @param arg_state Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_power_state(
                arg_state: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetPowerState">SetPowerState()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_set_power_state_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_set_power_state_sync() for the synchronous, blocking version of this method.
             * @param arg_state Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_power_state(
                arg_state: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_call_set_power_state().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_call_set_power_state().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_power_state_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetPowerState">SetPowerState()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_call_set_power_state() for the asynchronous version of this method.
             * @param arg_state Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_power_state_sync(arg_state: number, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetPrimarySimSlot">SetPrimarySimSlot()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_set_primary_sim_slot_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_set_primary_sim_slot_sync() for the synchronous, blocking version of this method.
             * @param arg_sim_slot Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set_primary_sim_slot(arg_sim_slot: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetPrimarySimSlot">SetPrimarySimSlot()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_set_primary_sim_slot_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_set_primary_sim_slot_sync() for the synchronous, blocking version of this method.
             * @param arg_sim_slot Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_primary_sim_slot(
                arg_sim_slot: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetPrimarySimSlot">SetPrimarySimSlot()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_set_primary_sim_slot_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_set_primary_sim_slot_sync() for the synchronous, blocking version of this method.
             * @param arg_sim_slot Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_primary_sim_slot(
                arg_sim_slot: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_call_set_primary_sim_slot().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_call_set_primary_sim_slot().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_primary_sim_slot_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetPrimarySimSlot">SetPrimarySimSlot()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_call_set_primary_sim_slot() for the asynchronous version of this method.
             * @param arg_sim_slot Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_primary_sim_slot_sync(arg_sim_slot: number, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.Command">Command()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param response Parameter to return.
             */
            complete_command(invocation: Gio.DBusMethodInvocation, response: string): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.CreateBearer">CreateBearer()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param path Parameter to return.
             */
            complete_create_bearer(invocation: Gio.DBusMethodInvocation, path: string): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.DeleteBearer">DeleteBearer()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_delete_bearer(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.Enable">Enable()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_enable(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.FactoryReset">FactoryReset()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_factory_reset(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.GetCellInfo">GetCellInfo()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param cell_info Parameter to return.
             */
            complete_get_cell_info(invocation: Gio.DBusMethodInvocation, cell_info: GLib.Variant): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.ListBearers">ListBearers()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param bearers Parameter to return.
             */
            complete_list_bearers(invocation: Gio.DBusMethodInvocation, bearers: string): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.Reset">Reset()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_reset(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetCurrentBands">SetCurrentBands()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_set_current_bands(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetCurrentCapabilities">SetCurrentCapabilities()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_set_current_capabilities(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetCurrentModes">SetCurrentModes()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_set_current_modes(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetPowerState">SetPowerState()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_set_power_state(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetPrimarySimSlot">SetPrimarySimSlot()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_set_primary_sim_slot(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Emits the <link linkend="gdbus-signal-org-freedesktop-ModemManager1-Modem.StateChanged">"StateChanged"</link> D-Bus signal.
             * @param arg_old Argument to pass with the signal.
             * @param arg_new Argument to pass with the signal.
             * @param arg_reason Argument to pass with the signal.
             */
            emit_state_changed(arg_old: number, arg_new: number, arg_reason: number): void;
            vfunc_handle_command(invocation: Gio.DBusMethodInvocation, arg_cmd: string, arg_timeout: number): boolean;
            vfunc_handle_create_bearer(invocation: Gio.DBusMethodInvocation, arg_properties: GLib.Variant): boolean;
            vfunc_handle_delete_bearer(invocation: Gio.DBusMethodInvocation, arg_bearer: string): boolean;
            vfunc_handle_enable(invocation: Gio.DBusMethodInvocation, arg_enable: boolean): boolean;
            vfunc_handle_factory_reset(invocation: Gio.DBusMethodInvocation, arg_code: string): boolean;
            vfunc_handle_get_cell_info(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_list_bearers(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_reset(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_set_current_bands(invocation: Gio.DBusMethodInvocation, arg_bands: GLib.Variant): boolean;
            vfunc_handle_set_current_capabilities(
                invocation: Gio.DBusMethodInvocation,
                arg_capabilities: number,
            ): boolean;
            vfunc_handle_set_current_modes(invocation: Gio.DBusMethodInvocation, arg_modes: GLib.Variant): boolean;
            vfunc_handle_set_power_state(invocation: Gio.DBusMethodInvocation, arg_state: number): boolean;
            vfunc_handle_set_primary_sim_slot(invocation: Gio.DBusMethodInvocation, arg_sim_slot: number): boolean;
            vfunc_state_changed(arg_old: number, arg_new: number, arg_reason: number): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace Modem3gpp {
            // Constructor properties interface

            interface ConstructorProps
                extends GdbusModem3gppProxy.ConstructorProps,
                    Gio.AsyncInitable.ConstructorProps,
                    Gio.DBusInterface.ConstructorProps,
                    Gio.Initable.ConstructorProps,
                    GdbusModem3gpp.ConstructorProps {}
        }

        /**
         * The #MMModem3gpp structure contains private data and should only be accessed
         * using the provided API.
         */
        class Modem3gpp
            extends GdbusModem3gppProxy
            implements Gio.AsyncInitable<Modem3gpp>, Gio.DBusInterface, Gio.Initable, GdbusModem3gpp
        {
            static $gtype: GObject.GType<Modem3gpp>;

            // Constructors

            constructor(properties?: Partial<Modem3gpp.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Methods

            /**
             * Asynchronously disables the modem personalization lock.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_3gpp_disable_facility_lock_finish() to get the result of
             * the operation.
             * @param facility Single bit value describing the modem personalization lock to disable.
             * @param control_key String with control key required to unlock the personalization.
             * @param cancellable A #GCancellable or %NULL.
             */
            disable_facility_lock(
                facility: Modem3gppFacility | null,
                control_key: string,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronously disables the modem personalization lock.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_3gpp_disable_facility_lock_finish() to get the result of
             * the operation.
             * @param facility Single bit value describing the modem personalization lock to disable.
             * @param control_key String with control key required to unlock the personalization.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            disable_facility_lock(
                facility: Modem3gppFacility | null,
                control_key: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously disables the modem personalization lock.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_3gpp_disable_facility_lock_finish() to get the result of
             * the operation.
             * @param facility Single bit value describing the modem personalization lock to disable.
             * @param control_key String with control key required to unlock the personalization.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            disable_facility_lock(
                facility: Modem3gppFacility | null,
                control_key: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_modem_3gpp_disable_facility_lock().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_3gpp_disable_facility_lock().
             * @returns %TRUE if the operation was successful, %FALSE if @error is set.
             */
            disable_facility_lock_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously disables facility lock.
             *
             * The calling thread is blocked until a reply is received.
             * See mm_modem_3gpp_disable_facility_lock() for the asynchronous
             * version of this method.
             * @param facility Single bit value describing the modem personalization lock to disable.
             * @param control_key String with control key required to unlock the personalization.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the operation was successful, %FALSE if @error is set.
             */
            disable_facility_lock_sync(
                facility: Modem3gppFacility | null,
                control_key: string,
                cancellable?: Gio.Cancellable | null,
            ): boolean;
            /**
             * Gets a copy of the <ulink url="http://en.wikipedia.org/wiki/Imei">IMEI</ulink>,
             * as reported by this #MMModem3gpp.
             * @returns The IMEI, or %NULL if none available. The returned value should be freed with g_free().
             */
            dup_imei(): string;
            /**
             * Gets a copy of the DBus path of the initial EPS #MMBearer exposed in this
             * #MMModem3gpp.
             * @returns The DBus path of the #MMBearer, or %NULL if none available. The returned value should be freed with g_free().
             */
            dup_initial_eps_bearer_path(): string;
            /**
             * Gets a copy of the code of the operator to which the mobile is currently
             * registered.
             *
             * Returned in the format <literal>"MCCMNC"</literal>, where
             * <literal>MCC</literal> is the three-digit ITU E.212 Mobile Country Code
             * and <literal>MNC</literal> is the two- or three-digit GSM Mobile Network
             * Code. e.g. e<literal>"31026"</literal> or <literal>"310260"</literal>.
             * @returns The operator code, or %NULL if none available. The returned value should be freed with g_free().
             */
            dup_operator_code(): string;
            /**
             * Gets a copy of the name of the operator to which the mobile is
             * currently registered.
             * @returns The operator name, or %NULL if none available. The returned value should be freed with g_free().
             */
            dup_operator_name(): string;
            /**
             * Gets a copy of the DBus path of the #MMObject object which implements this
             * interface.
             * @returns The DBus path of the #MMObject. The returned value should be freed with g_free().
             */
            dup_path(): string;
            /**
             * Get the list of facilities for which PIN locking is enabled.
             * @returns A bitmask of #MMModem3gppFacility flags, specifying which facilities have locks enabled.
             */
            get_enabled_facility_locks(): Modem3gppFacility;
            /**
             * Get the UE mode of operation for EPS.
             * @returns A #MMModem3gppEpsUeModeOperation.
             */
            get_eps_ue_mode_operation(): Modem3gppEpsUeModeOperation;
            /**
             * Gets the <ulink url="http://en.wikipedia.org/wiki/Imei">IMEI</ulink>,
             * as reported by this #MMModem3gpp.
             *
             * <warning>The returned value is only valid until the property changes so
             * it is only safe to use this function on the thread where
             * `self` was constructed. Use mm_modem_3gpp_dup_imei() if on another
             * thread.</warning>
             * @returns The IMEI, or %NULL if none available.
             */
            get_imei(): string;
            /**
             * Asynchronously gets the initial EPS #MMBearer object exposed by this
             * #MMModem3gpp.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_3gpp_get_initial_eps_bearer_finish() to get the result of the
             * operation.
             *
             * See mm_modem_3gpp_get_initial_eps_bearer_sync() for the synchronous, blocking
             * version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            get_initial_eps_bearer(cancellable?: Gio.Cancellable | null): Promise<Bearer>;
            /**
             * Asynchronously gets the initial EPS #MMBearer object exposed by this
             * #MMModem3gpp.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_3gpp_get_initial_eps_bearer_finish() to get the result of the
             * operation.
             *
             * See mm_modem_3gpp_get_initial_eps_bearer_sync() for the synchronous, blocking
             * version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            get_initial_eps_bearer(
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously gets the initial EPS #MMBearer object exposed by this
             * #MMModem3gpp.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_3gpp_get_initial_eps_bearer_finish() to get the result of the
             * operation.
             *
             * See mm_modem_3gpp_get_initial_eps_bearer_sync() for the synchronous, blocking
             * version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            get_initial_eps_bearer(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<Bearer> | void;
            /**
             * Finishes an operation started with mm_modem_3gpp_get_initial_eps_bearer().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_3gpp_get_initial_eps_bearer().
             * @returns a #MMSim or #NULL if @error is set. The returned value should be freed with g_object_unref().
             */
            get_initial_eps_bearer_finish(res: Gio.AsyncResult): Bearer;
            /**
             * Gets a #MMBearerProperties object specifying the settings configured in
             * the device to use when attaching to the LTE network.
             *
             * <warning>The values reported by `self` are not updated when the values in the
             * interface change. Instead, the client is expected to call
             * mm_modem_3gpp_get_initial_eps_bearer_settings() again to get a new
             * #MMBearerProperties with the new values.</warning>
             * @returns A #MMBearerProperties that must be freed with g_object_unref() or %NULL if unknown.
             */
            get_initial_eps_bearer_settings(): BearerProperties;
            /**
             * Synchronously gets the initial EPS #MMBearer object exposed by this
             * #MMModem3gpp.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_3gpp_get_initial_eps_bearer() for the asynchronous version of this
             * method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns a #MMBearer or #NULL if @error is set. The returned value should be freed with g_object_unref().
             */
            get_initial_eps_bearer_sync(cancellable?: Gio.Cancellable | null): Bearer;
            /**
             * Gets a #MMNr5gRegistrationSettings object including the configured 5GNR
             * registration settings.
             *
             * <warning>The values reported by `self` are not updated when the values in the
             * interface change. Instead, the client is expected to call
             * mm_modem_3gpp_get_nr5g_registration_settings() again to get a new
             * #MMNr5gRegistrationSettings with the new values.</warning>
             * @returns A #MMNr5gRegistrationSettings that must be freed with g_object_unref() or %NULL if unknown.
             */
            get_nr5g_registration_settings(): Nr5gRegistrationSettings;
            /**
             * Gets the code of the operator to which the mobile is currently registered.
             *
             * Returned in the format <literal>"MCCMNC"</literal>, where
             * <literal>MCC</literal> is the three-digit ITU E.212 Mobile Country Code
             * and <literal>MNC</literal> is the two- or three-digit GSM Mobile Network
             * Code. e.g. e<literal>"31026"</literal> or <literal>"310260"</literal>.
             *
             * If the <literal>MCC</literal> and <literal>MNC</literal> are not known
             * or the mobile is not registered to a mobile network, this property will
             * be a zero-length (blank) string.
             *
             * <warning>The returned value is only valid until the property changes so
             * it is only safe to use this function on the thread where
             * `self` was constructed. Use mm_modem_3gpp_dup_operator_code() if on another
             * thread.</warning>
             * @returns The operator code, or %NULL if none available.
             */
            get_operator_code(): string;
            /**
             * Gets the name of the operator to which the mobile is
             * currently registered.
             *
             * <warning>The returned value is only valid until the property changes so
             * it is only safe to use this function on the thread where
             * `self` was constructed. Use mm_modem_3gpp_dup_operator_name() if on another
             * thread.</warning>
             * @returns The operator name, or %NULL if none available.
             */
            get_operator_name(): string;
            /**
             * Get the packet domain service state.
             * @returns A #MMModem3gppPacketServiceState value, specifying the current PS attach  state.
             */
            get_packet_service_state(): Modem3gppPacketServiceState;
            /**
             * Gets the DBus path of the #MMObject which implements this interface.
             * @returns The DBus path of the #MMObject object.
             */
            get_path(): string;
            /**
             * Get the list of #MMPco received from the network.
             * @returns a list of #MMPco objects, or #NULL if @error is set. The returned value should be freed with g_list_free_full() using g_object_unref() as #GDestroyNotify function.
             */
            get_pco(): Pco[];
            /**
             * Get the the mobile registration status as defined in 3GPP TS 27.007
             * section 10.1.19.
             * @returns A #MMModem3gppRegistrationState value, specifying the current registration state.
             */
            get_registration_state(): Modem3gppRegistrationState;
            /**
             * Get the current subscription status of the account. This value is only
             * available after the modem attempts to register with the network.
             *
             * The value of this property can only be obtained with operator specific logic
             * (e.g. processing specific PCO info), and therefore it doesn't make sense to
             * expose it in the ModemManager interface.
             * @returns A #MMModem3gppSubscriptionState value, specifying the current subscription state.
             */
            get_subscription_state(): Modem3gppSubscriptionState;
            /**
             * Gets a #MMBearerProperties object specifying the settings configured in
             * the device to use when attaching to the LTE network.
             *
             * <warning>The returned value is only valid until the property changes so
             * it is only safe to use this function on the thread where
             * `self` was constructed. Use mm_modem_3gpp_get_initial_eps_bearer_settings()
             * if on another thread.</warning>
             * @returns A #MMBearerProperties. Do not free the returned value, it belongs to @self.
             */
            peek_initial_eps_bearer_settings(): BearerProperties;
            /**
             * Gets a #MMNr5gRegistrationSettings object including the configured 5GNR
             * registration settings.
             *
             * <warning>The returned value is only valid until the property changes so
             * it is only safe to use this function on the thread where
             * `self` was constructed. Use mm_modem_3gpp_get_nr5g_registration_settings()
             * if on another thread.</warning>
             * @returns A #MMNr5gRegistrationSettings Do not free the returned value, it belongs to @self.
             */
            peek_nr5g_registration_settings(): Nr5gRegistrationSettings;
            /**
             * Asynchronously requests registration with a given mobile network.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_3gpp_register_finish() to get the result of the operation.
             *
             * See mm_modem_3gpp_register_sync() for the synchronous, blocking version of
             * this method.
             * @param network_id The operator ID to register. An empty string can be used to  register to the home network.
             * @param cancellable A #GCancellable or %NULL.
             */
            register(network_id: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously requests registration with a given mobile network.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_3gpp_register_finish() to get the result of the operation.
             *
             * See mm_modem_3gpp_register_sync() for the synchronous, blocking version of
             * this method.
             * @param network_id The operator ID to register. An empty string can be used to  register to the home network.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            register(
                network_id: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously requests registration with a given mobile network.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_3gpp_register_finish() to get the result of the operation.
             *
             * See mm_modem_3gpp_register_sync() for the synchronous, blocking version of
             * this method.
             * @param network_id The operator ID to register. An empty string can be used to  register to the home network.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            register(
                network_id: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_modem_3gpp_register().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_3gpp_register().
             * @returns %TRUE if the modem was registered, %FALSE if @error is set.
             */
            register_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously requests registration with a given mobile network.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_3gpp_register() for the asynchronous version of this method.
             * @param network_id The operator ID to register. An empty string can be used to  register to the home network.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the modem was registered, %FALSE if @error is set.
             */
            register_sync(network_id: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously requests to scan available 3GPP networks.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_3gpp_scan_finish() to get the result of the operation.
             *
             * See mm_modem_3gpp_scan_sync() for the synchronous, blocking version of this
             * method.
             * @param cancellable A #GCancellable or %NULL.
             */
            scan(cancellable?: Gio.Cancellable | null): Promise<Modem3gppNetwork[]>;
            /**
             * Asynchronously requests to scan available 3GPP networks.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_3gpp_scan_finish() to get the result of the operation.
             *
             * See mm_modem_3gpp_scan_sync() for the synchronous, blocking version of this
             * method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            scan(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously requests to scan available 3GPP networks.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_3gpp_scan_finish() to get the result of the operation.
             *
             * See mm_modem_3gpp_scan_sync() for the synchronous, blocking version of this
             * method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            scan(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<Modem3gppNetwork[]> | void;
            /**
             * Finishes an operation started with mm_modem_3gpp_scan().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_3gpp_scan().
             * @returns a list of #MMModem3gppNetwork structs, or #NULL if @error is set. The returned value should be freed with g_list_free_full() using mm_modem_3gpp_network_free() as #GDestroyNotify function.
             */
            scan_finish(res: Gio.AsyncResult): Modem3gppNetwork[];
            /**
             * Synchronously requests to scan available 3GPP networks.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_3gpp_scan() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns a list of #MMModem3gppNetwork structs, or #NULL if @error is set. The returned value should be freed with g_list_free_full() using mm_modem_3gpp_network_free() as #GDestroyNotify function.
             */
            scan_sync(cancellable?: Gio.Cancellable | null): Modem3gppNetwork[];
            /**
             * Asynchronously sends the carrier lock information to the modem.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_location_inject_assistance_data_finish() to get the result of the
             * operation.
             *
             * See mm_modem_3gpp_set_carrier_lock_sync() for the synchronous,
             * blocking version of this method.
             * @param data Carrier lock information.
             * @param cancellable A #GCancellable or %NULL.
             */
            set_carrier_lock(data: Uint8Array | string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously sends the carrier lock information to the modem.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_location_inject_assistance_data_finish() to get the result of the
             * operation.
             *
             * See mm_modem_3gpp_set_carrier_lock_sync() for the synchronous,
             * blocking version of this method.
             * @param data Carrier lock information.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            set_carrier_lock(
                data: Uint8Array | string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously sends the carrier lock information to the modem.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_location_inject_assistance_data_finish() to get the result of the
             * operation.
             *
             * See mm_modem_3gpp_set_carrier_lock_sync() for the synchronous,
             * blocking version of this method.
             * @param data Carrier lock information.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            set_carrier_lock(
                data: Uint8Array | string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_modem_3gpp_set_carrier_lock().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem3gpp_call_set_carrier_lock().
             * @returns %TRUE if the call succeded, %FALSE if @error is set.
             */
            set_carrier_lock_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously sends the carrier lock information to the modem..
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_3gpp_set_carrier_lock() for the asynchronous version of this method.
             * @param data Carrier lock information.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the carrier network info is successfully send, %FALSE if @error is set.
             */
            set_carrier_lock_sync(data: Uint8Array | string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously requests to update the EPS UE mode of operation.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_3gpp_set_eps_ue_mode_operation_finish() to get the result of the
             * operation.
             *
             * See mm_modem_3gpp_set_eps_ue_mode_operation_sync() for the synchronous,
             * blocking version of this method. The calling thread is blocked until a reply
             * is received.
             * @param mode A #MMModem3gppEpsUeModeOperation.
             * @param cancellable A #GCancellable or %NULL.
             */
            set_eps_ue_mode_operation(
                mode: Modem3gppEpsUeModeOperation | null,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronously requests to update the EPS UE mode of operation.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_3gpp_set_eps_ue_mode_operation_finish() to get the result of the
             * operation.
             *
             * See mm_modem_3gpp_set_eps_ue_mode_operation_sync() for the synchronous,
             * blocking version of this method. The calling thread is blocked until a reply
             * is received.
             * @param mode A #MMModem3gppEpsUeModeOperation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            set_eps_ue_mode_operation(
                mode: Modem3gppEpsUeModeOperation | null,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously requests to update the EPS UE mode of operation.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_3gpp_set_eps_ue_mode_operation_finish() to get the result of the
             * operation.
             *
             * See mm_modem_3gpp_set_eps_ue_mode_operation_sync() for the synchronous,
             * blocking version of this method. The calling thread is blocked until a reply
             * is received.
             * @param mode A #MMModem3gppEpsUeModeOperation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            set_eps_ue_mode_operation(
                mode: Modem3gppEpsUeModeOperation | null,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_modem_3gpp_set_eps_ue_mode_operation().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_3gpp_set_eps_ue_mode_operation().
             * @returns %TRUE if the operation was successful, %FALSE if @error is set.
             */
            set_eps_ue_mode_operation_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously requests to update the EPS UE mode of operation.
             *
             * The calling thread is blocked until a reply is received.
             * See mm_modem_3gpp_set_eps_ue_mode_operation() for the asynchronous version
             * of this method.
             * @param mode A #MMModem3gppEpsUeModeOperation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the operation was successful, %FALSE if @error is set.
             */
            set_eps_ue_mode_operation_sync(
                mode: Modem3gppEpsUeModeOperation | null,
                cancellable?: Gio.Cancellable | null,
            ): boolean;
            /**
             * Asynchronously configures the settings for the initial LTE default bearer.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_3gpp_set_initial_eps_bearer_settings_finish() to get the result of
             * the operation.
             * @param config A #MMBearerProperties object with the properties to use.
             * @param cancellable A #GCancellable or %NULL.
             */
            set_initial_eps_bearer_settings(
                config: BearerProperties,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronously configures the settings for the initial LTE default bearer.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_3gpp_set_initial_eps_bearer_settings_finish() to get the result of
             * the operation.
             * @param config A #MMBearerProperties object with the properties to use.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            set_initial_eps_bearer_settings(
                config: BearerProperties,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously configures the settings for the initial LTE default bearer.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_3gpp_set_initial_eps_bearer_settings_finish() to get the result of
             * the operation.
             * @param config A #MMBearerProperties object with the properties to use.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            set_initial_eps_bearer_settings(
                config: BearerProperties,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with
             * mm_modem_3gpp_set_initial_eps_bearer_settings().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_3gpp_set_initial_eps_bearer_settings().
             * @returns %TRUE if the operation was successful, %FALSE if @error is set.
             */
            set_initial_eps_bearer_settings_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously configures the settings for the initial LTE default bearer.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_3gpp_set_initial_eps_bearer_settings() for the asynchronous
             * version of this method.
             * @param config A #MMBearerProperties object with the properties to use.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the operation was successful, %FALSE if @error is set.
             */
            set_initial_eps_bearer_settings_sync(
                config: BearerProperties,
                cancellable?: Gio.Cancellable | null,
            ): boolean;
            /**
             * Asynchronously configures the 5GNR registration settings.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_3gpp_set_nr5g_registration_settings_finish() to get the result of the operation.
             *
             * See mm_modem_3gpp_set_nr5g_registration_settings_sync() for the synchronous,
             * blocking version of this method.
             * @param settings A #MMNr5gRegistrationSettings.
             * @param cancellable A #GCancellable or %NULL.
             */
            set_nr5g_registration_settings(
                settings: Nr5gRegistrationSettings,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronously configures the 5GNR registration settings.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_3gpp_set_nr5g_registration_settings_finish() to get the result of the operation.
             *
             * See mm_modem_3gpp_set_nr5g_registration_settings_sync() for the synchronous,
             * blocking version of this method.
             * @param settings A #MMNr5gRegistrationSettings.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            set_nr5g_registration_settings(
                settings: Nr5gRegistrationSettings,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously configures the 5GNR registration settings.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_3gpp_set_nr5g_registration_settings_finish() to get the result of the operation.
             *
             * See mm_modem_3gpp_set_nr5g_registration_settings_sync() for the synchronous,
             * blocking version of this method.
             * @param settings A #MMNr5gRegistrationSettings.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            set_nr5g_registration_settings(
                settings: Nr5gRegistrationSettings,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_modem_3gpp_set_nr5g_registration_settings().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_3gpp_set_nr5g_registration_settings().
             * @returns %TRUE if the operation was successful, %FALSE if @error is set.
             */
            set_nr5g_registration_settings_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously configures the 5GNR registration settings.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_3gpp_set_nr5g_registration_settings() for the asynchronous
             * version of this method.
             * @param settings A #MMNr5gRegistrationSettings.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the operation was successful, %FALSE if @error is set.
             */
            set_nr5g_registration_settings_sync(
                settings: Nr5gRegistrationSettings,
                cancellable?: Gio.Cancellable | null,
            ): boolean;
            /**
             * Asynchronously tries to attach or detach from the packet domain service.
             *
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_3gpp_set_packet_service_state_finish() to get the result of the operation.
             *
             * See mm_modem_3gpp_set_packet_service_state_sync() for the synchronous,
             * blocking version of this method.
             * @param state A #MMModem3gppPacketServiceState.
             * @param cancellable A #GCancellable or %NULL.
             */
            set_packet_service_state(
                state: Modem3gppPacketServiceState | null,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronously tries to attach or detach from the packet domain service.
             *
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_3gpp_set_packet_service_state_finish() to get the result of the operation.
             *
             * See mm_modem_3gpp_set_packet_service_state_sync() for the synchronous,
             * blocking version of this method.
             * @param state A #MMModem3gppPacketServiceState.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            set_packet_service_state(
                state: Modem3gppPacketServiceState | null,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously tries to attach or detach from the packet domain service.
             *
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_3gpp_set_packet_service_state_finish() to get the result of the operation.
             *
             * See mm_modem_3gpp_set_packet_service_state_sync() for the synchronous,
             * blocking version of this method.
             * @param state A #MMModem3gppPacketServiceState.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            set_packet_service_state(
                state: Modem3gppPacketServiceState | null,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_modem_3gpp_set_packet_service_state().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_3gpp_set_packet_service_state().
             * @returns %TRUE if the operation was successful, %FALSE if @error is set.
             */
            set_packet_service_state_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously tries to attach or detach from the packet domain service.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_3gpp_set_packet_service_state() for the asynchronous version of
             * this method.
             * @param state A #MMModem3gppPacketServiceState.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the operation was successful, %FALSE if @error is set.
             */
            set_packet_service_state_sync(
                state: Modem3gppPacketServiceState | null,
                cancellable?: Gio.Cancellable | null,
            ): boolean;

            // Inherited properties
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.EnabledFacilityLocks">"EnabledFacilityLocks"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get enabled_facility_locks(): number;
            set enabled_facility_locks(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.EnabledFacilityLocks">"EnabledFacilityLocks"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get enabledFacilityLocks(): number;
            set enabledFacilityLocks(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.EpsUeModeOperation">"EpsUeModeOperation"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get eps_ue_mode_operation(): number;
            set eps_ue_mode_operation(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.EpsUeModeOperation">"EpsUeModeOperation"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get epsUeModeOperation(): number;
            set epsUeModeOperation(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.Imei">"Imei"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get imei(): string;
            set imei(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.InitialEpsBearer">"InitialEpsBearer"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get initial_eps_bearer(): string;
            set initial_eps_bearer(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.InitialEpsBearer">"InitialEpsBearer"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get initialEpsBearer(): string;
            set initialEpsBearer(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.InitialEpsBearerSettings">"InitialEpsBearerSettings"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get initial_eps_bearer_settings(): GLib.Variant;
            set initial_eps_bearer_settings(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.InitialEpsBearerSettings">"InitialEpsBearerSettings"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get initialEpsBearerSettings(): GLib.Variant;
            set initialEpsBearerSettings(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.Nr5gRegistrationSettings">"Nr5gRegistrationSettings"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get nr5g_registration_settings(): GLib.Variant;
            set nr5g_registration_settings(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.Nr5gRegistrationSettings">"Nr5gRegistrationSettings"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get nr5gRegistrationSettings(): GLib.Variant;
            set nr5gRegistrationSettings(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.OperatorCode">"OperatorCode"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get operator_code(): string;
            set operator_code(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.OperatorCode">"OperatorCode"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get operatorCode(): string;
            set operatorCode(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.OperatorName">"OperatorName"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get operator_name(): string;
            set operator_name(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.OperatorName">"OperatorName"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get operatorName(): string;
            set operatorName(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.PacketServiceState">"PacketServiceState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get packet_service_state(): number;
            set packet_service_state(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.PacketServiceState">"PacketServiceState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get packetServiceState(): number;
            set packetServiceState(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.Pco">"Pco"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get pco(): GLib.Variant;
            set pco(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.RegistrationState">"RegistrationState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get registration_state(): number;
            set registration_state(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.RegistrationState">"RegistrationState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get registrationState(): number;
            set registrationState(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.SubscriptionState">"SubscriptionState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get subscription_state(): number;
            set subscription_state(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.SubscriptionState">"SubscriptionState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get subscriptionState(): number;
            set subscriptionState(val: number);

            // Inherited methods
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            init_async(io_priority: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             * @returns %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present.
             */
            init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Finishes the async construction for the various g_async_initable_new
             * calls, returning the created object or %NULL on error.
             * @param res the #GAsyncResult from the callback
             * @returns a newly created #GObject,      or %NULL on error. Free with g_object_unref().
             */
            new_finish(res: Gio.AsyncResult): Modem3gpp;
            // Conflicted with ModemManager.GdbusModem3gppProxy.new_finish
            new_finish(...args: never[]): any;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            vfunc_init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             */
            vfunc_init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.DisableFacilityLock">DisableFacilityLock()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_disable_facility_lock_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_disable_facility_lock_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_disable_facility_lock(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.DisableFacilityLock">DisableFacilityLock()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_disable_facility_lock_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_disable_facility_lock_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_disable_facility_lock(
                arg_properties: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.DisableFacilityLock">DisableFacilityLock()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_disable_facility_lock_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_disable_facility_lock_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_disable_facility_lock(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem3gpp_call_disable_facility_lock().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem3gpp_call_disable_facility_lock().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_disable_facility_lock_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.DisableFacilityLock">DisableFacilityLock()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem3gpp_call_disable_facility_lock() for the asynchronous version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_disable_facility_lock_sync(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
            ): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.Register">Register()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_register_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_register_sync() for the synchronous, blocking version of this method.
             * @param arg_operator_id Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_register(arg_operator_id: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.Register">Register()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_register_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_register_sync() for the synchronous, blocking version of this method.
             * @param arg_operator_id Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_register(
                arg_operator_id: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.Register">Register()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_register_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_register_sync() for the synchronous, blocking version of this method.
             * @param arg_operator_id Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_register(
                arg_operator_id: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem3gpp_call_register().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem3gpp_call_register().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_register_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.Register">Register()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem3gpp_call_register() for the asynchronous version of this method.
             * @param arg_operator_id Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_register_sync(arg_operator_id: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.Scan">Scan()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_scan_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_scan_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_scan(cancellable?: Gio.Cancellable | null): Promise<GLib.Variant | null>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.Scan">Scan()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_scan_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_scan_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_scan(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.Scan">Scan()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_scan_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_scan_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_scan(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<GLib.Variant | null> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem3gpp_call_scan().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem3gpp_call_scan().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_scan_finish(res: Gio.AsyncResult): [boolean, GLib.Variant | null];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.Scan">Scan()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem3gpp_call_scan() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_scan_sync(cancellable?: Gio.Cancellable | null): [boolean, GLib.Variant | null];
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetCarrierLock">SetCarrierLock()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_set_carrier_lock_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_set_carrier_lock_sync() for the synchronous, blocking version of this method.
             * @param arg_data Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set_carrier_lock(arg_data: GLib.Variant, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetCarrierLock">SetCarrierLock()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_set_carrier_lock_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_set_carrier_lock_sync() for the synchronous, blocking version of this method.
             * @param arg_data Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_carrier_lock(
                arg_data: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetCarrierLock">SetCarrierLock()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_set_carrier_lock_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_set_carrier_lock_sync() for the synchronous, blocking version of this method.
             * @param arg_data Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_carrier_lock(
                arg_data: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem3gpp_call_set_carrier_lock().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem3gpp_call_set_carrier_lock().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_carrier_lock_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetCarrierLock">SetCarrierLock()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem3gpp_call_set_carrier_lock() for the asynchronous version of this method.
             * @param arg_data Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_carrier_lock_sync(arg_data: GLib.Variant, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetEpsUeModeOperation">SetEpsUeModeOperation()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_set_eps_ue_mode_operation_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_set_eps_ue_mode_operation_sync() for the synchronous, blocking version of this method.
             * @param arg_mode Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set_eps_ue_mode_operation(arg_mode: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetEpsUeModeOperation">SetEpsUeModeOperation()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_set_eps_ue_mode_operation_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_set_eps_ue_mode_operation_sync() for the synchronous, blocking version of this method.
             * @param arg_mode Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_eps_ue_mode_operation(
                arg_mode: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetEpsUeModeOperation">SetEpsUeModeOperation()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_set_eps_ue_mode_operation_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_set_eps_ue_mode_operation_sync() for the synchronous, blocking version of this method.
             * @param arg_mode Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_eps_ue_mode_operation(
                arg_mode: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem3gpp_call_set_eps_ue_mode_operation().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem3gpp_call_set_eps_ue_mode_operation().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_eps_ue_mode_operation_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetEpsUeModeOperation">SetEpsUeModeOperation()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem3gpp_call_set_eps_ue_mode_operation() for the asynchronous version of this method.
             * @param arg_mode Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_eps_ue_mode_operation_sync(arg_mode: number, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetInitialEpsBearerSettings">SetInitialEpsBearerSettings()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_set_initial_eps_bearer_settings_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_set_initial_eps_bearer_settings_sync() for the synchronous, blocking version of this method.
             * @param arg_settings Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set_initial_eps_bearer_settings(
                arg_settings: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetInitialEpsBearerSettings">SetInitialEpsBearerSettings()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_set_initial_eps_bearer_settings_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_set_initial_eps_bearer_settings_sync() for the synchronous, blocking version of this method.
             * @param arg_settings Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_initial_eps_bearer_settings(
                arg_settings: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetInitialEpsBearerSettings">SetInitialEpsBearerSettings()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_set_initial_eps_bearer_settings_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_set_initial_eps_bearer_settings_sync() for the synchronous, blocking version of this method.
             * @param arg_settings Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_initial_eps_bearer_settings(
                arg_settings: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem3gpp_call_set_initial_eps_bearer_settings().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem3gpp_call_set_initial_eps_bearer_settings().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_initial_eps_bearer_settings_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetInitialEpsBearerSettings">SetInitialEpsBearerSettings()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem3gpp_call_set_initial_eps_bearer_settings() for the asynchronous version of this method.
             * @param arg_settings Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_initial_eps_bearer_settings_sync(
                arg_settings: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
            ): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetNr5gRegistrationSettings">SetNr5gRegistrationSettings()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_set_nr5g_registration_settings_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_set_nr5g_registration_settings_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set_nr5g_registration_settings(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetNr5gRegistrationSettings">SetNr5gRegistrationSettings()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_set_nr5g_registration_settings_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_set_nr5g_registration_settings_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_nr5g_registration_settings(
                arg_properties: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetNr5gRegistrationSettings">SetNr5gRegistrationSettings()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_set_nr5g_registration_settings_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_set_nr5g_registration_settings_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_nr5g_registration_settings(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem3gpp_call_set_nr5g_registration_settings().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem3gpp_call_set_nr5g_registration_settings().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_nr5g_registration_settings_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetNr5gRegistrationSettings">SetNr5gRegistrationSettings()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem3gpp_call_set_nr5g_registration_settings() for the asynchronous version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_nr5g_registration_settings_sync(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
            ): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetPacketServiceState">SetPacketServiceState()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_set_packet_service_state_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_set_packet_service_state_sync() for the synchronous, blocking version of this method.
             * @param arg_state Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set_packet_service_state(arg_state: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetPacketServiceState">SetPacketServiceState()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_set_packet_service_state_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_set_packet_service_state_sync() for the synchronous, blocking version of this method.
             * @param arg_state Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_packet_service_state(
                arg_state: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetPacketServiceState">SetPacketServiceState()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_set_packet_service_state_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_set_packet_service_state_sync() for the synchronous, blocking version of this method.
             * @param arg_state Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_packet_service_state(
                arg_state: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem3gpp_call_set_packet_service_state().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem3gpp_call_set_packet_service_state().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_packet_service_state_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetPacketServiceState">SetPacketServiceState()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem3gpp_call_set_packet_service_state() for the asynchronous version of this method.
             * @param arg_state Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_packet_service_state_sync(arg_state: number, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.DisableFacilityLock">DisableFacilityLock()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_disable_facility_lock(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.Register">Register()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_register(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.Scan">Scan()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param results Parameter to return.
             */
            complete_scan(invocation: Gio.DBusMethodInvocation, results: GLib.Variant): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetCarrierLock">SetCarrierLock()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_set_carrier_lock(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetEpsUeModeOperation">SetEpsUeModeOperation()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_set_eps_ue_mode_operation(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetInitialEpsBearerSettings">SetInitialEpsBearerSettings()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_set_initial_eps_bearer_settings(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetNr5gRegistrationSettings">SetNr5gRegistrationSettings()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_set_nr5g_registration_settings(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetPacketServiceState">SetPacketServiceState()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_set_packet_service_state(invocation: Gio.DBusMethodInvocation): void;
            vfunc_handle_disable_facility_lock(
                invocation: Gio.DBusMethodInvocation,
                arg_properties: GLib.Variant,
            ): boolean;
            vfunc_handle_register(invocation: Gio.DBusMethodInvocation, arg_operator_id: string): boolean;
            vfunc_handle_scan(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_set_carrier_lock(invocation: Gio.DBusMethodInvocation, arg_data: GLib.Variant): boolean;
            vfunc_handle_set_eps_ue_mode_operation(invocation: Gio.DBusMethodInvocation, arg_mode: number): boolean;
            vfunc_handle_set_initial_eps_bearer_settings(
                invocation: Gio.DBusMethodInvocation,
                arg_settings: GLib.Variant,
            ): boolean;
            vfunc_handle_set_nr5g_registration_settings(
                invocation: Gio.DBusMethodInvocation,
                arg_properties: GLib.Variant,
            ): boolean;
            vfunc_handle_set_packet_service_state(invocation: Gio.DBusMethodInvocation, arg_state: number): boolean;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace Modem3gppProfileManager {
            // Constructor properties interface

            interface ConstructorProps
                extends GdbusModem3gppProfileManagerProxy.ConstructorProps,
                    Gio.AsyncInitable.ConstructorProps,
                    Gio.DBusInterface.ConstructorProps,
                    Gio.Initable.ConstructorProps,
                    GdbusModem3gppProfileManager.ConstructorProps {}
        }

        /**
         * The #MMModem3gppProfileManager structure contains private data and should only be accessed
         * using the provided API.
         */
        class Modem3gppProfileManager
            extends GdbusModem3gppProfileManagerProxy
            implements
                Gio.AsyncInitable<Modem3gppProfileManager>,
                Gio.DBusInterface,
                Gio.Initable,
                GdbusModem3gppProfileManager
        {
            static $gtype: GObject.GType<Modem3gppProfileManager>;

            // Constructors

            constructor(properties?: Partial<Modem3gppProfileManager.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Methods

            /**
             * Asynchronously deletes the connection profile.
             *
             * The `profile` should have at least the profile ID set for the delete operation
             * to succeed.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_3gpp_profile_manager_delete_finish() to get the result of the
             * operation.
             *
             * See mm_modem_3gpp_profile_manager_delete_sync() for the synchronous, blocking
             * version of this method.
             * @param profile A #MM3gppProfile.
             * @param cancellable A #GCancellable or %NULL.
             */
            ['delete'](profile: __3gppProfile, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously deletes the connection profile.
             *
             * The `profile` should have at least the profile ID set for the delete operation
             * to succeed.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_3gpp_profile_manager_delete_finish() to get the result of the
             * operation.
             *
             * See mm_modem_3gpp_profile_manager_delete_sync() for the synchronous, blocking
             * version of this method.
             * @param profile A #MM3gppProfile.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            ['delete'](
                profile: __3gppProfile,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously deletes the connection profile.
             *
             * The `profile` should have at least the profile ID set for the delete operation
             * to succeed.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_3gpp_profile_manager_delete_finish() to get the result of the
             * operation.
             *
             * See mm_modem_3gpp_profile_manager_delete_sync() for the synchronous, blocking
             * version of this method.
             * @param profile A #MM3gppProfile.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            ['delete'](
                profile: __3gppProfile,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_modem_3gpp_profile_manager_delete().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_3gpp_profile_manager_delete().
             * @returns %TRUE if the operation was successful, %FALSE if @error is set.
             */
            delete_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously deletes the connection profile.
             *
             * The `profile` should have at least the profile ID set for the delete operation
             * to succeed.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_3gpp_profile_manager_delete() for the asynchronous version of this
             * method.
             * @param profile A #MM3gppProfile.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the operation was successful, %FALSE if @error is set.
             */
            delete_sync(profile: __3gppProfile, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Gets a copy of the name of the field used as index in profile management
             * operations.
             * @returns The index field, or %NULL if none available. The returned value should be freed with g_free().
             */
            dup_index_field(): string;
            /**
             * Gets a copy of the DBus path of the #MMObject object which implements this
             * interface.
             * @returns The DBus path of the #MMObject. The returned value should be freed with g_free().
             */
            dup_path(): string;
            /**
             * Gets the name of the field used as index in profile management
             * operations.
             * @returns The index field, or %NULL if none available. Do not free the returned value, it belongs to @self.
             */
            get_index_field(): string;
            /**
             * Gets the DBus path of the #MMObject which implements this interface.
             * @returns The DBus path of the #MMObject object.
             */
            get_path(): string;
            /**
             * Asynchronously gets the list of available connection profiles.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_3gpp_profile_manager_list_finish() to get the result of the
             * operation.
             *
             * See mm_modem_3gpp_profile_manager_list_sync() for the synchronous, blocking
             * version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            list(cancellable?: Gio.Cancellable | null): Promise<__3gppProfile[] | null>;
            /**
             * Asynchronously gets the list of available connection profiles.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_3gpp_profile_manager_list_finish() to get the result of the
             * operation.
             *
             * See mm_modem_3gpp_profile_manager_list_sync() for the synchronous, blocking
             * version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            list(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously gets the list of available connection profiles.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_3gpp_profile_manager_list_finish() to get the result of the
             * operation.
             *
             * See mm_modem_3gpp_profile_manager_list_sync() for the synchronous, blocking
             * version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            list(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<__3gppProfile[] | null> | void;
            /**
             * Finishes an operation started with mm_modem_3gpp_profile_manager_list().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_3gpp_profile_manager_list().
             * @returns %TRUE if the list was correctly retrieved, %FALSE if @error is set.
             */
            list_finish(res: Gio.AsyncResult): [boolean, __3gppProfile[] | null];
            /**
             * Synchronously gets the list of available connection profiles.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_3gpp_profile_manager_list() for the asynchronous version of this
             * method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the list was correctly retrieved, %FALSE if @error is set.
             */
            list_sync(cancellable?: Gio.Cancellable | null): [boolean, __3gppProfile[] | null];
            /**
             * Asynchronously updates a connection profile with the settings
             * given in `profile`.
             *
             * If `profile` does not have an explicit profile ID set, a new profile will
             * be created.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_3gpp_profile_manager_set_finish() to get the result of the
             * operation.
             *
             * See mm_modem_3gpp_profile_manager_set_sync() for the synchronous, blocking
             * version of this method.
             * @param requested A #MM3gppProfile with the requested settings.
             * @param cancellable A #GCancellable or %NULL.
             */
            set(requested: __3gppProfile, cancellable?: Gio.Cancellable | null): Promise<__3gppProfile>;
            /**
             * Asynchronously updates a connection profile with the settings
             * given in `profile`.
             *
             * If `profile` does not have an explicit profile ID set, a new profile will
             * be created.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_3gpp_profile_manager_set_finish() to get the result of the
             * operation.
             *
             * See mm_modem_3gpp_profile_manager_set_sync() for the synchronous, blocking
             * version of this method.
             * @param requested A #MM3gppProfile with the requested settings.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            set(
                requested: __3gppProfile,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously updates a connection profile with the settings
             * given in `profile`.
             *
             * If `profile` does not have an explicit profile ID set, a new profile will
             * be created.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_3gpp_profile_manager_set_finish() to get the result of the
             * operation.
             *
             * See mm_modem_3gpp_profile_manager_set_sync() for the synchronous, blocking
             * version of this method.
             * @param requested A #MM3gppProfile with the requested settings.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            set(
                requested: __3gppProfile,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<__3gppProfile> | void;
            // Conflicted with GObject.Object.set
            set(...args: never[]): any;
            /**
             * Finishes an operation started with mm_modem_3gpp_profile_manager_set().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_3gpp_profile_manager_set().
             * @returns A #MM3gppProfile with the stored settings, or %NULL if @error is set.
             */
            set_finish(res: Gio.AsyncResult): __3gppProfile;
            /**
             * Synchronously updates a connection profile with the settings
             * given in `profile`.
             *
             * If `profile` does not have an explicit profile ID set, a new profile will
             * be created.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_3gpp_profile_manager_set() for the asynchronous version of this
             * method.
             * @param requested A #MM3gppProfile with the requested settings.
             * @param cancellable A #GCancellable or %NULL.
             * @returns A #MM3gppProfile with the stored settings, or %NULL if @error is set.
             */
            set_sync(requested: __3gppProfile, cancellable?: Gio.Cancellable | null): __3gppProfile;

            // Inherited properties
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.IndexField">"IndexField"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get index_field(): string;
            set index_field(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.IndexField">"IndexField"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get indexField(): string;
            set indexField(val: string);

            // Inherited methods
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            init_async(io_priority: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             * @returns %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present.
             */
            init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Finishes the async construction for the various g_async_initable_new
             * calls, returning the created object or %NULL on error.
             * @param res the #GAsyncResult from the callback
             * @returns a newly created #GObject,      or %NULL on error. Free with g_object_unref().
             */
            new_finish(res: Gio.AsyncResult): Modem3gppProfileManager;
            // Conflicted with ModemManager.GdbusModem3gppProfileManagerProxy.new_finish
            new_finish(...args: never[]): any;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            vfunc_init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             */
            vfunc_init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.Delete">Delete()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_profile_manager_call_delete_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_profile_manager_call_delete_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_delete(arg_properties: GLib.Variant, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.Delete">Delete()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_profile_manager_call_delete_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_profile_manager_call_delete_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_delete(
                arg_properties: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.Delete">Delete()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_profile_manager_call_delete_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_profile_manager_call_delete_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_delete(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem3gpp_profile_manager_call_delete().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem3gpp_profile_manager_call_delete().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_delete_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.Delete">Delete()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem3gpp_profile_manager_call_delete() for the asynchronous version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_delete_sync(arg_properties: GLib.Variant, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.List">List()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_profile_manager_call_list_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_profile_manager_call_list_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_list(cancellable?: Gio.Cancellable | null): Promise<GLib.Variant | null>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.List">List()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_profile_manager_call_list_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_profile_manager_call_list_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_list(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.List">List()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_profile_manager_call_list_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_profile_manager_call_list_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_list(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<GLib.Variant | null> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem3gpp_profile_manager_call_list().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem3gpp_profile_manager_call_list().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_list_finish(res: Gio.AsyncResult): [boolean, GLib.Variant | null];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.List">List()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem3gpp_profile_manager_call_list() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_list_sync(cancellable?: Gio.Cancellable | null): [boolean, GLib.Variant | null];
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.Set">Set()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_profile_manager_call_set_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_profile_manager_call_set_sync() for the synchronous, blocking version of this method.
             * @param arg_requested_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set(
                arg_requested_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
            ): Promise<GLib.Variant | null>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.Set">Set()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_profile_manager_call_set_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_profile_manager_call_set_sync() for the synchronous, blocking version of this method.
             * @param arg_requested_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set(
                arg_requested_properties: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.Set">Set()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_profile_manager_call_set_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_profile_manager_call_set_sync() for the synchronous, blocking version of this method.
             * @param arg_requested_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set(
                arg_requested_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<GLib.Variant | null> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem3gpp_profile_manager_call_set().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem3gpp_profile_manager_call_set().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_finish(res: Gio.AsyncResult): [boolean, GLib.Variant | null];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.Set">Set()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem3gpp_profile_manager_call_set() for the asynchronous version of this method.
             * @param arg_requested_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_sync(
                arg_requested_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
            ): [boolean, GLib.Variant | null];
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.Delete">Delete()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_delete(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.List">List()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param profiles Parameter to return.
             */
            complete_list(invocation: Gio.DBusMethodInvocation, profiles: GLib.Variant): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.Set">Set()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param stored_properties Parameter to return.
             */
            complete_set(invocation: Gio.DBusMethodInvocation, stored_properties: GLib.Variant): void;
            /**
             * Emits the <link linkend="gdbus-signal-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.Updated">"Updated"</link> D-Bus signal.
             */
            emit_updated(): void;
            vfunc_handle_delete(invocation: Gio.DBusMethodInvocation, arg_properties: GLib.Variant): boolean;
            vfunc_handle_list(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_set(invocation: Gio.DBusMethodInvocation, arg_requested_properties: GLib.Variant): boolean;
            vfunc_updated(): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace Modem3gppUssd {
            // Constructor properties interface

            interface ConstructorProps
                extends GdbusModem3gppUssdProxy.ConstructorProps,
                    Gio.AsyncInitable.ConstructorProps,
                    Gio.DBusInterface.ConstructorProps,
                    Gio.Initable.ConstructorProps,
                    GdbusModem3gppUssd.ConstructorProps {}
        }

        /**
         * The #MMModem3gppUssd structure contains private data and should only be accessed
         * using the provided API.
         */
        class Modem3gppUssd
            extends GdbusModem3gppUssdProxy
            implements Gio.AsyncInitable<Modem3gppUssd>, Gio.DBusInterface, Gio.Initable, GdbusModem3gppUssd
        {
            static $gtype: GObject.GType<Modem3gppUssd>;

            // Constructors

            constructor(properties?: Partial<Modem3gppUssd.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Methods

            /**
             * Asynchronously cancels an ongoing USSD session, either mobile or network
             * initiated.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_3gpp_ussd_cancel_finish() to get the result of the operation.
             *
             * See mm_modem_3gpp_ussd_cancel_sync() for the synchronous, blocking version
             * of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            cancel(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously cancels an ongoing USSD session, either mobile or network
             * initiated.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_3gpp_ussd_cancel_finish() to get the result of the operation.
             *
             * See mm_modem_3gpp_ussd_cancel_sync() for the synchronous, blocking version
             * of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            cancel(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously cancels an ongoing USSD session, either mobile or network
             * initiated.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_3gpp_ussd_cancel_finish() to get the result of the operation.
             *
             * See mm_modem_3gpp_ussd_cancel_sync() for the synchronous, blocking version
             * of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            cancel(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_modem_3gpp_ussd_cancel().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_3gpp_ussd_cancel().
             * @returns %TRUE if the session was successfully cancelled, %FALSE if @error is set.
             */
            cancel_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously cancels an ongoing USSD session, either mobile or network
             * initiated.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_3gpp_ussd_cancel() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the session was successfully cancelled, %FALSE if @error is set.
             */
            cancel_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Gets a copy of any pending network-initiated request to which no USSD
             * response is required.
             * @returns The network notification, or %NULL if none available. The returned value should be freed with g_free().
             */
            dup_network_notification(): string;
            /**
             * Gets a copy of any pending network-initiated request.
             * @returns The network request, or %NULL if none available. The returned value should be freed with g_free().
             */
            dup_network_request(): string;
            /**
             * Gets a copy of the DBus path of the #MMObject object which implements this
             * interface.
             * @returns The DBus path of the #MMObject. The returned value should be freed with g_free().
             */
            dup_path(): string;
            /**
             * Gets any pending network-initiated request to which no USSD response is
             * required.
             *
             * <warning>The returned value is only valid until the property changes so it is
             * only safe to use this function on the thread where `self` was constructed. Use
             * mm_modem_3gpp_ussd_dup_network_notification() if on another thread.</warning>
             * @returns The network notification, or %NULL if none available.
             */
            get_network_notification(): string;
            /**
             * Gets any pending network-initiated request.
             *
             * <warning>The returned value is only valid until the property changes so
             * it is only safe to use this function on the thread where
             * `self` was constructed. Use mm_modem_3gpp_ussd_dup_network_request() if on
             * another thread.</warning>
             * @returns The network request, or %NULL if none available.
             */
            get_network_request(): string;
            /**
             * Gets the DBus path of the #MMObject which implements this interface.
             * @returns The DBus path of the #MMObject object.
             */
            get_path(): string;
            /**
             * Get the state of the ongoing USSD session, if any.
             * @returns A #MMModem3gppUssdSessionState value, specifying the current state.
             */
            get_state(): Modem3gppUssdSessionState;
            /**
             * Asynchronously sends a USSD command string to the network initiating a USSD
             * session.
             *
             * When the request is handled by the network, the method returns the
             * response or an appropriate error. The network may be awaiting further
             * response from the ME after returning from this method and no new command.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_3gpp_ussd_initiate_finish() to get the result of the operation.
             *
             * See mm_modem_3gpp_ussd_initiate_sync() for the synchronous, blocking version
             * of this method.
             * @param command The command to start the USSD session with.
             * @param cancellable A #GCancellable or %NULL.
             */
            initiate(command: string, cancellable?: Gio.Cancellable | null): Promise<string>;
            /**
             * Asynchronously sends a USSD command string to the network initiating a USSD
             * session.
             *
             * When the request is handled by the network, the method returns the
             * response or an appropriate error. The network may be awaiting further
             * response from the ME after returning from this method and no new command.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_3gpp_ussd_initiate_finish() to get the result of the operation.
             *
             * See mm_modem_3gpp_ussd_initiate_sync() for the synchronous, blocking version
             * of this method.
             * @param command The command to start the USSD session with.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            initiate(
                command: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously sends a USSD command string to the network initiating a USSD
             * session.
             *
             * When the request is handled by the network, the method returns the
             * response or an appropriate error. The network may be awaiting further
             * response from the ME after returning from this method and no new command.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_3gpp_ussd_initiate_finish() to get the result of the operation.
             *
             * See mm_modem_3gpp_ussd_initiate_sync() for the synchronous, blocking version
             * of this method.
             * @param command The command to start the USSD session with.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            initiate(
                command: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<string> | void;
            /**
             * Finishes an operation started with mm_modem_3gpp_ussd_initiate().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_3gpp_ussd_initiate().
             * @returns The response from the network, if any. The returned value should be freed with g_free().
             */
            initiate_finish(res: Gio.AsyncResult): string;
            /**
             * Synchronously sends a USSD command string to the network initiating a USSD
             * session.
             *
             * When the request is handled by the network, the method returns the
             * response or an appropriate error. The network may be awaiting further
             * response from the ME after returning from this method and no new command.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_3gpp_ussd_initiate() for the asynchronous version of this method.
             * @param command The command to start the USSD session with.
             * @param cancellable A #GCancellable or %NULL.
             * @returns The response from the network, if any. The returned value should be freed with g_free().
             */
            initiate_sync(command: string, cancellable?: Gio.Cancellable | null): string;
            /**
             * Asynchronously responds to a USSD request that is either initiated by the
             * mobile network, or that is awaiting further input after a previous call to
             * mm_modem_3gpp_ussd_initiate().
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_3gpp_ussd_respond_finish() to get the result of the operation.
             *
             * See mm_modem_3gpp_ussd_respond_sync() for the synchronous, blocking version
             * of this method.
             * @param response The response to network-initiated USSD command, or a response to a  request for further input.
             * @param cancellable A #GCancellable or %NULL.
             */
            respond(response: string, cancellable?: Gio.Cancellable | null): Promise<string>;
            /**
             * Asynchronously responds to a USSD request that is either initiated by the
             * mobile network, or that is awaiting further input after a previous call to
             * mm_modem_3gpp_ussd_initiate().
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_3gpp_ussd_respond_finish() to get the result of the operation.
             *
             * See mm_modem_3gpp_ussd_respond_sync() for the synchronous, blocking version
             * of this method.
             * @param response The response to network-initiated USSD command, or a response to a  request for further input.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            respond(
                response: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously responds to a USSD request that is either initiated by the
             * mobile network, or that is awaiting further input after a previous call to
             * mm_modem_3gpp_ussd_initiate().
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_3gpp_ussd_respond_finish() to get the result of the operation.
             *
             * See mm_modem_3gpp_ussd_respond_sync() for the synchronous, blocking version
             * of this method.
             * @param response The response to network-initiated USSD command, or a response to a  request for further input.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            respond(
                response: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<string> | void;
            /**
             * Finishes an operation started with mm_modem_3gpp_ussd_respond().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_3gpp_ussd_respond().
             * @returns The network reply to this response to the network-initiated USSD command. The reply may require further responses. The returned value should be freed with g_free().
             */
            respond_finish(res: Gio.AsyncResult): string;
            /**
             * Synchronously responds to a USSD request that is either initiated by the
             * mobile network, or that is awaiting further input after a previous call to
             * mm_modem_3gpp_ussd_initiate().
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_3gpp_ussd_respond() for the asynchronous version of this method.
             * @param response The response to network-initiated USSD command, or a response to a  request for further input.
             * @param cancellable A #GCancellable or %NULL.
             * @returns The network reply to this response to the network-initiated USSD command. The reply may require further responses. The returned value should be freed with g_free().
             */
            respond_sync(response: string, cancellable?: Gio.Cancellable | null): string;

            // Inherited properties
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.NetworkNotification">"NetworkNotification"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get network_notification(): string;
            set network_notification(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.NetworkNotification">"NetworkNotification"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get networkNotification(): string;
            set networkNotification(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.NetworkRequest">"NetworkRequest"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get network_request(): string;
            set network_request(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.NetworkRequest">"NetworkRequest"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get networkRequest(): string;
            set networkRequest(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.State">"State"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get state(): number;
            set state(val: number);

            // Inherited methods
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            init_async(io_priority: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             * @returns %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present.
             */
            init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Finishes the async construction for the various g_async_initable_new
             * calls, returning the created object or %NULL on error.
             * @param res the #GAsyncResult from the callback
             * @returns a newly created #GObject,      or %NULL on error. Free with g_object_unref().
             */
            new_finish(res: Gio.AsyncResult): Modem3gppUssd;
            // Conflicted with ModemManager.GdbusModem3gppUssdProxy.new_finish
            new_finish(...args: never[]): any;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            vfunc_init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             */
            vfunc_init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.Cancel">Cancel()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_ussd_call_cancel_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_ussd_call_cancel_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_cancel(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.Cancel">Cancel()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_ussd_call_cancel_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_ussd_call_cancel_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_cancel(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.Cancel">Cancel()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_ussd_call_cancel_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_ussd_call_cancel_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_cancel(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem3gpp_ussd_call_cancel().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem3gpp_ussd_call_cancel().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_cancel_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.Cancel">Cancel()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem3gpp_ussd_call_cancel() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_cancel_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.Initiate">Initiate()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_ussd_call_initiate_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_ussd_call_initiate_sync() for the synchronous, blocking version of this method.
             * @param arg_command Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_initiate(arg_command: string, cancellable?: Gio.Cancellable | null): Promise<string>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.Initiate">Initiate()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_ussd_call_initiate_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_ussd_call_initiate_sync() for the synchronous, blocking version of this method.
             * @param arg_command Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_initiate(
                arg_command: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.Initiate">Initiate()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_ussd_call_initiate_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_ussd_call_initiate_sync() for the synchronous, blocking version of this method.
             * @param arg_command Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_initiate(
                arg_command: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<string> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem3gpp_ussd_call_initiate().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem3gpp_ussd_call_initiate().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_initiate_finish(res: Gio.AsyncResult): [boolean, string];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.Initiate">Initiate()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem3gpp_ussd_call_initiate() for the asynchronous version of this method.
             * @param arg_command Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_initiate_sync(arg_command: string, cancellable?: Gio.Cancellable | null): [boolean, string];
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.Respond">Respond()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_ussd_call_respond_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_ussd_call_respond_sync() for the synchronous, blocking version of this method.
             * @param arg_response Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_respond(arg_response: string, cancellable?: Gio.Cancellable | null): Promise<string>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.Respond">Respond()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_ussd_call_respond_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_ussd_call_respond_sync() for the synchronous, blocking version of this method.
             * @param arg_response Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_respond(
                arg_response: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.Respond">Respond()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_ussd_call_respond_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_ussd_call_respond_sync() for the synchronous, blocking version of this method.
             * @param arg_response Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_respond(
                arg_response: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<string> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem3gpp_ussd_call_respond().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem3gpp_ussd_call_respond().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_respond_finish(res: Gio.AsyncResult): [boolean, string];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.Respond">Respond()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem3gpp_ussd_call_respond() for the asynchronous version of this method.
             * @param arg_response Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_respond_sync(arg_response: string, cancellable?: Gio.Cancellable | null): [boolean, string];
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.Cancel">Cancel()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_cancel(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.Initiate">Initiate()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param reply Parameter to return.
             */
            complete_initiate(invocation: Gio.DBusMethodInvocation, reply: string): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.Respond">Respond()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param reply Parameter to return.
             */
            complete_respond(invocation: Gio.DBusMethodInvocation, reply: string): void;
            vfunc_handle_cancel(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_initiate(invocation: Gio.DBusMethodInvocation, arg_command: string): boolean;
            vfunc_handle_respond(invocation: Gio.DBusMethodInvocation, arg_response: string): boolean;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace ModemCdma {
            // Constructor properties interface

            interface ConstructorProps
                extends GdbusModemCdmaProxy.ConstructorProps,
                    Gio.AsyncInitable.ConstructorProps,
                    Gio.DBusInterface.ConstructorProps,
                    Gio.Initable.ConstructorProps,
                    GdbusModemCdma.ConstructorProps {}
        }

        /**
         * The #MMModemCdma structure contains private data and should only be accessed
         * using the provided API.
         */
        class ModemCdma
            extends GdbusModemCdmaProxy
            implements Gio.AsyncInitable<ModemCdma>, Gio.DBusInterface, Gio.Initable, GdbusModemCdma
        {
            static $gtype: GObject.GType<ModemCdma>;

            // Constructors

            constructor(properties?: Partial<ModemCdma.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Methods

            /**
             * Asynchronously requests to provision the modem for use with a given carrier
             * using the modem's OTA activation functionality, if any.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_cdma_activate_finish() to get the result of the operation.
             *
             * See mm_modem_cdma_activate_sync() for the synchronous, blocking version of
             * this method.
             * @param carrier Name of the carrier.
             * @param cancellable A #GCancellable or %NULL.
             */
            activate(carrier: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously requests to provision the modem for use with a given carrier
             * using the modem's OTA activation functionality, if any.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_cdma_activate_finish() to get the result of the operation.
             *
             * See mm_modem_cdma_activate_sync() for the synchronous, blocking version of
             * this method.
             * @param carrier Name of the carrier.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            activate(
                carrier: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously requests to provision the modem for use with a given carrier
             * using the modem's OTA activation functionality, if any.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_cdma_activate_finish() to get the result of the operation.
             *
             * See mm_modem_cdma_activate_sync() for the synchronous, blocking version of
             * this method.
             * @param carrier Name of the carrier.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            activate(
                carrier: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_modem_cdma_activate().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_cdma_activate().
             * @returns %TRUE if the activation was successful, %FALSE if @error is set.
             */
            activate_finish(res: Gio.AsyncResult): boolean;
            /**
             * Asynchronously requests to provision the modem with the given properties.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from.
             * You can then call mm_modem_cdma_activate_manual_finish() to get the result of
             * the operation.
             *
             * See mm_modem_cdma_activate_manual_sync() for the synchronous, blocking
             * version of this method.
             * @param properties A #MMCdmaManualActivationProperties.
             * @param cancellable A #GCancellable or %NULL.
             */
            activate_manual(
                properties: CdmaManualActivationProperties,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronously requests to provision the modem with the given properties.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from.
             * You can then call mm_modem_cdma_activate_manual_finish() to get the result of
             * the operation.
             *
             * See mm_modem_cdma_activate_manual_sync() for the synchronous, blocking
             * version of this method.
             * @param properties A #MMCdmaManualActivationProperties.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            activate_manual(
                properties: CdmaManualActivationProperties,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously requests to provision the modem with the given properties.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from.
             * You can then call mm_modem_cdma_activate_manual_finish() to get the result of
             * the operation.
             *
             * See mm_modem_cdma_activate_manual_sync() for the synchronous, blocking
             * version of this method.
             * @param properties A #MMCdmaManualActivationProperties.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            activate_manual(
                properties: CdmaManualActivationProperties,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_modem_cdma_activate_manual().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_cdma_activate_manual().
             * @returns %TRUE if the activation was successful, %FALSE if @error is set.
             */
            activate_manual_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously requests to provision the modem with the given properties.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_cdma_activate_manual() for the asynchronous version of this method.
             * @param properties A #MMCdmaManualActivationProperties.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the activation was successful, %FALSE if @error is set.
             */
            activate_manual_sync(
                properties: CdmaManualActivationProperties,
                cancellable?: Gio.Cancellable | null,
            ): boolean;
            /**
             * Synchronously requests to provision the modem for use with a given carrier
             * using the modem's OTA activation functionality, if any.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_cdma_activate() for the asynchronous version of this method.
             * @param carrier Name of the carrier.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the activation was successful, %FALSE if @error is set.
             */
            activate_sync(carrier: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Gets a copy of the
             * <ulink url="http://en.wikipedia.org/wiki/Electronic_serial_number">Electronic Serial Number</ulink>,
             * as reported by this #MMModemCdma.
             *
             * The ESN is superceded by MEID, but still used in older devices.
             * @returns The ESN, or %NULL if none available. The returned value should be freed with g_free().
             */
            dup_esn(): string;
            /**
             * Gets a copy of the
             * <ulink url="http://en.wikipedia.org/wiki/MEID">Mobile Equipment Identifier</ulink>,
             * as reported by this #MMModemCdma.
             * @returns The MEID, or %NULL if none available. The returned value should be freed with g_free().
             */
            dup_meid(): string;
            /**
             * Gets a copy of the DBus path of the #MMObject object which implements this
             * interface.
             * @returns The DBus path of the #MMObject. The returned value should be freed with g_free().
             */
            dup_path(): string;
            /**
             * Gets the state of the activation in the 3GPP2 network.
             * @returns a #MMModemCdmaActivationState.
             */
            get_activation_state(): ModemCdmaActivationState;
            /**
             * Gets the state of the registration in the CDMA 1x network.
             * @returns a #MMModemCdmaRegistrationState.
             */
            get_cdma1x_registration_state(): ModemCdmaRegistrationState;
            /**
             * Gets the
             * <ulink url="http://en.wikipedia.org/wiki/Electronic_serial_number">Electronic Serial Number</ulink>,
             * as reported by this #MMModemCdma.
             *
             * The ESN is superceded by MEID, but still used in older devices.
             *
             * <warning>The returned value is only valid until the property changes so it is
             * only safe to use this function on the thread where `self` was constructed. Use
             * mm_modem_cdma_dup_esn() if on another thread.</warning>
             * @returns The ESN, or %NULL if none available.
             */
            get_esn(): string;
            /**
             * Gets the state of the registration in the EV-DO network.
             * @returns a #MMModemCdmaRegistrationState.
             */
            get_evdo_registration_state(): ModemCdmaRegistrationState;
            /**
             * Gets the
             * <ulink url="http://en.wikipedia.org/wiki/MEID">Mobile Equipment Identifier</ulink>,
             * as reported by this #MMModemCdma.
             *
             * <warning>The returned value is only valid until the property changes so it is
             * only safe to use this function on the thread where `self` was constructed. Use
             * mm_modem_cdma_dup_meid() if on another thread.</warning>
             * @returns The MEID, or %NULL if none available.
             */
            get_meid(): string;
            /**
             * Gets the
             * <ulink url="http://en.wikipedia.org/wiki/Network_Identification_Number">Network Identifier</ulink>
             * of the serving CDMA 1x network, if known, and if the modem is registered with
             * a CDMA 1x network.
             * @returns The NID, or %MM_MODEM_CDMA_NID_UNKNOWN.
             */
            get_nid(): number;
            /**
             * Gets the DBus path of the #MMObject which implements this interface.
             * @returns The DBus path of the #MMObject object.
             */
            get_path(): string;
            /**
             * Gets the
             * <ulink url="http://en.wikipedia.org/wiki/System_Identification_Number">System Identifier</ulink>
             * of the serving CDMA 1x network, if known, and if the modem is registered with
             * a CDMA 1x network.
             * @returns The SID, or %MM_MODEM_CDMA_SID_UNKNOWN.
             */
            get_sid(): number;

            // Inherited properties
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-ModemCdma.ActivationState">"ActivationState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get activation_state(): number;
            set activation_state(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-ModemCdma.ActivationState">"ActivationState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get activationState(): number;
            set activationState(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-ModemCdma.Cdma1xRegistrationState">"Cdma1xRegistrationState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get cdma1x_registration_state(): number;
            set cdma1x_registration_state(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-ModemCdma.Cdma1xRegistrationState">"Cdma1xRegistrationState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get cdma1xRegistrationState(): number;
            set cdma1xRegistrationState(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-ModemCdma.Esn">"Esn"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get esn(): string;
            set esn(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-ModemCdma.EvdoRegistrationState">"EvdoRegistrationState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get evdo_registration_state(): number;
            set evdo_registration_state(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-ModemCdma.EvdoRegistrationState">"EvdoRegistrationState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get evdoRegistrationState(): number;
            set evdoRegistrationState(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-ModemCdma.Meid">"Meid"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get meid(): string;
            set meid(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-ModemCdma.Nid">"Nid"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get nid(): number;
            set nid(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-ModemCdma.Sid">"Sid"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get sid(): number;
            set sid(val: number);

            // Inherited methods
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            init_async(io_priority: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             * @returns %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present.
             */
            init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Finishes the async construction for the various g_async_initable_new
             * calls, returning the created object or %NULL on error.
             * @param res the #GAsyncResult from the callback
             * @returns a newly created #GObject,      or %NULL on error. Free with g_object_unref().
             */
            new_finish(res: Gio.AsyncResult): ModemCdma;
            // Conflicted with ModemManager.GdbusModemCdmaProxy.new_finish
            new_finish(...args: never[]): any;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            vfunc_init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             */
            vfunc_init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-ModemCdma.Activate">Activate()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_cdma_call_activate_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_cdma_call_activate_sync() for the synchronous, blocking version of this method.
             * @param arg_carrier_code Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_activate(arg_carrier_code: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-ModemCdma.Activate">Activate()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_cdma_call_activate_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_cdma_call_activate_sync() for the synchronous, blocking version of this method.
             * @param arg_carrier_code Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_activate(
                arg_carrier_code: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-ModemCdma.Activate">Activate()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_cdma_call_activate_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_cdma_call_activate_sync() for the synchronous, blocking version of this method.
             * @param arg_carrier_code Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_activate(
                arg_carrier_code: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_cdma_call_activate().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_cdma_call_activate().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_activate_finish(res: Gio.AsyncResult): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-ModemCdma.ActivateManual">ActivateManual()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_cdma_call_activate_manual_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_cdma_call_activate_manual_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_activate_manual(arg_properties: GLib.Variant, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-ModemCdma.ActivateManual">ActivateManual()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_cdma_call_activate_manual_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_cdma_call_activate_manual_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_activate_manual(
                arg_properties: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-ModemCdma.ActivateManual">ActivateManual()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_cdma_call_activate_manual_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_cdma_call_activate_manual_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_activate_manual(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_cdma_call_activate_manual().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_cdma_call_activate_manual().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_activate_manual_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-ModemCdma.ActivateManual">ActivateManual()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_cdma_call_activate_manual() for the asynchronous version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_activate_manual_sync(arg_properties: GLib.Variant, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-ModemCdma.Activate">Activate()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_cdma_call_activate() for the asynchronous version of this method.
             * @param arg_carrier_code Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_activate_sync(arg_carrier_code: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-ModemCdma.Activate">Activate()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_activate(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-ModemCdma.ActivateManual">ActivateManual()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_activate_manual(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Emits the <link linkend="gdbus-signal-org-freedesktop-ModemManager1-Modem-ModemCdma.ActivationStateChanged">"ActivationStateChanged"</link> D-Bus signal.
             * @param arg_activation_state Argument to pass with the signal.
             * @param arg_activation_error Argument to pass with the signal.
             * @param arg_status_changes Argument to pass with the signal.
             */
            emit_activation_state_changed(
                arg_activation_state: number,
                arg_activation_error: number,
                arg_status_changes: GLib.Variant,
            ): void;
            vfunc_activation_state_changed(
                arg_activation_state: number,
                arg_activation_error: number,
                arg_status_changes: GLib.Variant,
            ): void;
            vfunc_handle_activate(invocation: Gio.DBusMethodInvocation, arg_carrier_code: string): boolean;
            vfunc_handle_activate_manual(invocation: Gio.DBusMethodInvocation, arg_properties: GLib.Variant): boolean;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace ModemFirmware {
            // Constructor properties interface

            interface ConstructorProps
                extends GdbusModemFirmwareProxy.ConstructorProps,
                    Gio.AsyncInitable.ConstructorProps,
                    Gio.DBusInterface.ConstructorProps,
                    Gio.Initable.ConstructorProps,
                    GdbusModemFirmware.ConstructorProps {}
        }

        /**
         * The #MMModemFirmware structure contains private data and should only be accessed
         * using the provided API.
         */
        class ModemFirmware
            extends GdbusModemFirmwareProxy
            implements Gio.AsyncInitable<ModemFirmware>, Gio.DBusInterface, Gio.Initable, GdbusModemFirmware
        {
            static $gtype: GObject.GType<ModemFirmware>;

            // Constructors

            constructor(properties?: Partial<ModemFirmware.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Methods

            /**
             * Gets a copy of the DBus path of the #MMObject object which implements this
             * interface.
             * @returns The DBus path of the #MMObject. The returned value should be freed with g_free().
             */
            dup_path(): string;
            /**
             * Gets the DBus path of the #MMObject which implements this interface.
             * @returns The DBus path of the #MMObject object.
             */
            get_path(): string;
            /**
             * Gets a #MMFirmwareUpdateSettings object specifying the expected update
             * settings.
             *
             * <warning>The values reported by `self` are not updated when the values in the
             * interface change. Instead, the client is expected to call
             * mm_modem_firmware_get_update_settings() again to get a new
             * #MMFirmwareUpdateSettings with the new values.</warning>
             * @returns A #MMFirmwareUpdateSettings that must be freed with g_object_unref() or %NULL if unknown.
             */
            get_update_settings(): FirmwareUpdateSettings;
            /**
             * Asynchronously gets the list of available firmware images.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_firmware_list_finish() to get the result of the operation.
             *
             * See mm_modem_firmware_list_sync() for the synchronous, blocking version of
             * this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            list(
                cancellable?: Gio.Cancellable | null,
            ): Promise<[FirmwareProperties | null, FirmwareProperties[] | null]>;
            /**
             * Asynchronously gets the list of available firmware images.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_firmware_list_finish() to get the result of the operation.
             *
             * See mm_modem_firmware_list_sync() for the synchronous, blocking version of
             * this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            list(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously gets the list of available firmware images.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_firmware_list_finish() to get the result of the operation.
             *
             * See mm_modem_firmware_list_sync() for the synchronous, blocking version of
             * this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            list(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<[FirmwareProperties | null, FirmwareProperties[] | null]> | void;
            /**
             * Finishes an operation started with mm_modem_firmware_list().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_firmware_list().
             * @returns %TRUE if the list was correctly retrieved, %FALSE if @error is set.
             */
            list_finish(res: Gio.AsyncResult): [boolean, FirmwareProperties | null, FirmwareProperties[] | null];
            /**
             * Synchronously gets the list of available firmware images.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_firmware_list() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the list was correctly retrieved, %FALSE if @error is set.
             */
            list_sync(
                cancellable?: Gio.Cancellable | null,
            ): [boolean, FirmwareProperties | null, FirmwareProperties[] | null];
            /**
             * Gets a #MMFirmwareUpdateSettings object specifying the expected update
             * settings.
             *
             * <warning>The returned value is only valid until the property changes so
             * it is only safe to use this function on the thread where
             * `self` was constructed. Use mm_modem_firmware_get_update_settings() if on
             * another thread.</warning>
             * @returns A #MMFirmwareUpdateSettings. Do not free the returned value, it belongs to @self.
             */
            peek_update_settings(): FirmwareUpdateSettings;
            /**
             * Asynchronously selects a firmware image to boot.
             *
             * <warning>The modem will possibly disappear once this action is run, as it
             * needs to reboot in order to select the new image.</warning>
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_firmware_select_finish() to get the result of the operation.
             *
             * See mm_modem_firmware_select_sync() for the synchronous, blocking version of
             * this method.
             * @param unique_id Unique ID of the firmware image to select.
             * @param cancellable A #GCancellable or %NULL.
             */
            select(unique_id: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously selects a firmware image to boot.
             *
             * <warning>The modem will possibly disappear once this action is run, as it
             * needs to reboot in order to select the new image.</warning>
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_firmware_select_finish() to get the result of the operation.
             *
             * See mm_modem_firmware_select_sync() for the synchronous, blocking version of
             * this method.
             * @param unique_id Unique ID of the firmware image to select.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            select(
                unique_id: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously selects a firmware image to boot.
             *
             * <warning>The modem will possibly disappear once this action is run, as it
             * needs to reboot in order to select the new image.</warning>
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_firmware_select_finish() to get the result of the operation.
             *
             * See mm_modem_firmware_select_sync() for the synchronous, blocking version of
             * this method.
             * @param unique_id Unique ID of the firmware image to select.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            select(
                unique_id: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_modem_firmware_select().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_firmware_select().
             * @returns %TRUE if the selection was successful, %FALSE if @error is set.
             */
            select_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously selects a firmware image to boot.
             *
             * <warning>The modem will possibly disappear once this action is run, as it
             * needs to reboot in order to select the new image.</warning>
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_firmware_select() for the asynchronous version of this method.
             * @param unique_id Unique ID of the firmware image to select.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the selection was successful, %FALSE if @error is set.
             */
            select_sync(unique_id: string, cancellable?: Gio.Cancellable | null): boolean;

            // Inherited properties
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Firmware.UpdateSettings">"UpdateSettings"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get update_settings(): GLib.Variant;
            set update_settings(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Firmware.UpdateSettings">"UpdateSettings"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get updateSettings(): GLib.Variant;
            set updateSettings(val: GLib.Variant);

            // Inherited methods
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            init_async(io_priority: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             * @returns %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present.
             */
            init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Finishes the async construction for the various g_async_initable_new
             * calls, returning the created object or %NULL on error.
             * @param res the #GAsyncResult from the callback
             * @returns a newly created #GObject,      or %NULL on error. Free with g_object_unref().
             */
            new_finish(res: Gio.AsyncResult): ModemFirmware;
            // Conflicted with ModemManager.GdbusModemFirmwareProxy.new_finish
            new_finish(...args: never[]): any;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            vfunc_init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             */
            vfunc_init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Firmware.List">List()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_firmware_call_list_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_firmware_call_list_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_list(cancellable?: Gio.Cancellable | null): Promise<[string, GLib.Variant | null]>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Firmware.List">List()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_firmware_call_list_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_firmware_call_list_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_list(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Firmware.List">List()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_firmware_call_list_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_firmware_call_list_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_list(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<[string, GLib.Variant | null]> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_firmware_call_list().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_firmware_call_list().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_list_finish(res: Gio.AsyncResult): [boolean, string, GLib.Variant | null];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Firmware.List">List()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_firmware_call_list() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_list_sync(cancellable?: Gio.Cancellable | null): [boolean, string, GLib.Variant | null];
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Firmware.Select">Select()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_firmware_call_select_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_firmware_call_select_sync() for the synchronous, blocking version of this method.
             * @param arg_uniqueid Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_select(arg_uniqueid: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Firmware.Select">Select()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_firmware_call_select_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_firmware_call_select_sync() for the synchronous, blocking version of this method.
             * @param arg_uniqueid Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_select(
                arg_uniqueid: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Firmware.Select">Select()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_firmware_call_select_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_firmware_call_select_sync() for the synchronous, blocking version of this method.
             * @param arg_uniqueid Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_select(
                arg_uniqueid: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_firmware_call_select().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_firmware_call_select().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_select_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Firmware.Select">Select()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_firmware_call_select() for the asynchronous version of this method.
             * @param arg_uniqueid Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_select_sync(arg_uniqueid: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Firmware.List">List()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param selected Parameter to return.
             * @param installed Parameter to return.
             */
            complete_list(invocation: Gio.DBusMethodInvocation, selected: string, installed: GLib.Variant): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Firmware.Select">Select()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_select(invocation: Gio.DBusMethodInvocation): void;
            vfunc_handle_list(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_select(invocation: Gio.DBusMethodInvocation, arg_uniqueid: string): boolean;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace ModemLocation {
            // Constructor properties interface

            interface ConstructorProps
                extends GdbusModemLocationProxy.ConstructorProps,
                    Gio.AsyncInitable.ConstructorProps,
                    Gio.DBusInterface.ConstructorProps,
                    Gio.Initable.ConstructorProps,
                    GdbusModemLocation.ConstructorProps {}
        }

        /**
         * The #MMModemLocation structure contains private data and should only be accessed
         * using the provided API.
         */
        class ModemLocation
            extends GdbusModemLocationProxy
            implements Gio.AsyncInitable<ModemLocation>, Gio.DBusInterface, Gio.Initable, GdbusModemLocation
        {
            static $gtype: GObject.GType<ModemLocation>;

            // Constructors

            constructor(properties?: Partial<ModemLocation.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Methods

            /**
             * Gets the list of assistance data servers.
             * @returns a %NULL-terminated array of server addresses, or %NULL if none available. The returned value should be freed with g_strfreev().
             */
            dup_assistance_data_servers(): string[];
            /**
             * Gets a copy of the DBus path of the #MMObject object which implements this
             * interface.
             * @returns The DBus path of the #MMObject. The returned value should be freed with g_free().
             */
            dup_path(): string;
            /**
             * Gets the address of the SUPL server.
             * @returns The SUPL server address, or %NULL if none available. The returned value should be freed with g_free().
             */
            dup_supl_server(): string;
            /**
             * Asynchronously gets the current 3GPP location information.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_location_get_3gpp_finish() to get the result of the operation.
             *
             * See mm_modem_location_get_3gpp_sync() for the synchronous, blocking version
             * of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            get_3gpp(cancellable?: Gio.Cancellable | null): Promise<Location3gpp>;
            /**
             * Asynchronously gets the current 3GPP location information.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_location_get_3gpp_finish() to get the result of the operation.
             *
             * See mm_modem_location_get_3gpp_sync() for the synchronous, blocking version
             * of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            get_3gpp(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously gets the current 3GPP location information.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_location_get_3gpp_finish() to get the result of the operation.
             *
             * See mm_modem_location_get_3gpp_sync() for the synchronous, blocking version
             * of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            get_3gpp(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<Location3gpp> | void;
            /**
             * Finishes an operation started with mm_modem_location_get_3gpp().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_location_get_3gpp().
             * @returns A #MMLocation3gpp, or #NULL if not available. The  returned value should be freed with g_object_unref().
             */
            get_3gpp_finish(res: Gio.AsyncResult): Location3gpp;
            /**
             * Synchronously gets the current 3GPP location information.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_location_get_3gpp() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns A #MMLocation3gpp, or #NULL if not available. The returned value should be freed with g_object_unref().
             */
            get_3gpp_sync(cancellable?: Gio.Cancellable | null): Location3gpp;
            /**
             * Gets the list of assistance data servers.
             *
             * <warning>The returned value is only valid until the property changes so it is
             * only safe to use this function on the thread where `self` was constructed. Use
             * mm_modem_location_dup_assistance_data_servers() if on another thread.
             * </warning>
             * @returns a %NULL-terminated array of server addresses, or %NULL if none available. Do not free the returned value, it belongs to @self.
             */
            get_assistance_data_servers(): string[];
            /**
             * Gets a bitmask of the location capabilities supported by this
             * #MMModemLocation.
             * @returns A #MMModemLocationSource.
             */
            get_capabilities(): ModemLocationSource;
            /**
             * Asynchronously gets the current CDMA base station location information.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_location_get_cdma_bs_finish() to get the result of the operation.
             *
             * See mm_modem_location_get_cdma_bs_sync() for the synchronous, blocking
             * version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            get_cdma_bs(cancellable?: Gio.Cancellable | null): Promise<LocationCdmaBs>;
            /**
             * Asynchronously gets the current CDMA base station location information.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_location_get_cdma_bs_finish() to get the result of the operation.
             *
             * See mm_modem_location_get_cdma_bs_sync() for the synchronous, blocking
             * version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            get_cdma_bs(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously gets the current CDMA base station location information.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_location_get_cdma_bs_finish() to get the result of the operation.
             *
             * See mm_modem_location_get_cdma_bs_sync() for the synchronous, blocking
             * version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            get_cdma_bs(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<LocationCdmaBs> | void;
            /**
             * Finishes an operation started with mm_modem_location_get_cdma_bs().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_location_get_cdma_bs().
             * @returns A #MMLocationCdmaBs, or #NULL if not available. The returned value should be freed with g_object_unref().
             */
            get_cdma_bs_finish(res: Gio.AsyncResult): LocationCdmaBs;
            /**
             * Synchronously gets the current CDMA base station location information.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_location_get_cdma_bs() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns A #MMLocationCdmaBs, or #NULL if not available. The returned value should be freed with g_object_unref().
             */
            get_cdma_bs_sync(cancellable?: Gio.Cancellable | null): LocationCdmaBs;
            /**
             * Gets a bitmask of the location capabilities which are enabled in this #MMModemLocation.
             * @returns A #MMModemLocationSource.
             */
            get_enabled(): ModemLocationSource;
            /**
             * Asynchronously gets the current location information.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_location_get_full_finish() to get the result of the operation.
             *
             * See mm_modem_location_get_full_sync() for the synchronous, blocking version
             * of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            get_full(
                cancellable?: Gio.Cancellable | null,
            ): Promise<[Location3gpp | null, LocationGpsNmea | null, LocationGpsRaw | null, LocationCdmaBs | null]>;
            /**
             * Asynchronously gets the current location information.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_location_get_full_finish() to get the result of the operation.
             *
             * See mm_modem_location_get_full_sync() for the synchronous, blocking version
             * of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            get_full(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously gets the current location information.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_location_get_full_finish() to get the result of the operation.
             *
             * See mm_modem_location_get_full_sync() for the synchronous, blocking version
             * of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            get_full(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<
                [Location3gpp | null, LocationGpsNmea | null, LocationGpsRaw | null, LocationCdmaBs | null]
            > | void;
            /**
             * Finishes an operation started with mm_modem_location_get_full().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_location_get_full().
             * @returns %TRUE if the retrieval was successful, %FALSE if @error is set.
             */
            get_full_finish(
                res: Gio.AsyncResult,
            ): [boolean, Location3gpp | null, LocationGpsNmea | null, LocationGpsRaw | null, LocationCdmaBs | null];
            /**
             * Synchronously gets the current location information.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_location_get_full() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the setup was successful, %FALSE if @error is set.
             */
            get_full_sync(
                cancellable?: Gio.Cancellable | null,
            ): [boolean, Location3gpp | null, LocationGpsNmea | null, LocationGpsRaw | null, LocationCdmaBs | null];
            /**
             * Asynchronously gets the current GPS NMEA location information.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_location_get_gps_nmea_finish() to get the result of the operation.
             *
             * See mm_modem_location_get_gps_nmea_sync() for the synchronous, blocking
             * version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            get_gps_nmea(cancellable?: Gio.Cancellable | null): Promise<LocationGpsNmea>;
            /**
             * Asynchronously gets the current GPS NMEA location information.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_location_get_gps_nmea_finish() to get the result of the operation.
             *
             * See mm_modem_location_get_gps_nmea_sync() for the synchronous, blocking
             * version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            get_gps_nmea(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously gets the current GPS NMEA location information.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_location_get_gps_nmea_finish() to get the result of the operation.
             *
             * See mm_modem_location_get_gps_nmea_sync() for the synchronous, blocking
             * version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            get_gps_nmea(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<LocationGpsNmea> | void;
            /**
             * Finishes an operation started with mm_modem_location_get_gps_nmea().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_location_get_gps_nmea().
             * @returns A #MMLocationGpsNmea, or #NULL if not available. The returned value should be freed with g_object_unref().
             */
            get_gps_nmea_finish(res: Gio.AsyncResult): LocationGpsNmea;
            /**
             * Synchronously gets the current GPS NMEA location information.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_location_get_gps_nmea() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns A #MMLocationGpsNmea, or #NULL if not available. The returned value should be freed with g_object_unref().
             */
            get_gps_nmea_sync(cancellable?: Gio.Cancellable | null): LocationGpsNmea;
            /**
             * Asynchronously gets the current GPS raw location information.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_location_get_gps_raw_finish() to get the result of the operation.
             *
             * See mm_modem_location_get_gps_raw_sync() for the synchronous, blocking
             * version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            get_gps_raw(cancellable?: Gio.Cancellable | null): Promise<LocationGpsRaw>;
            /**
             * Asynchronously gets the current GPS raw location information.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_location_get_gps_raw_finish() to get the result of the operation.
             *
             * See mm_modem_location_get_gps_raw_sync() for the synchronous, blocking
             * version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            get_gps_raw(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously gets the current GPS raw location information.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_location_get_gps_raw_finish() to get the result of the operation.
             *
             * See mm_modem_location_get_gps_raw_sync() for the synchronous, blocking
             * version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            get_gps_raw(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<LocationGpsRaw> | void;
            /**
             * Finishes an operation started with mm_modem_location_get_gps_raw().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_location_get_gps_raw().
             * @returns A #MMLocationGpsRaw, or #NULL if not available. The returned value should be freed with g_object_unref().
             */
            get_gps_raw_finish(res: Gio.AsyncResult): LocationGpsRaw;
            /**
             * Synchronously gets the current GPS raw location information.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_location_get_gps_raw() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns A #MMLocationGpsRaw, or #NULL if not available. The returned value should be freed with g_object_unref().
             */
            get_gps_raw_sync(cancellable?: Gio.Cancellable | null): LocationGpsRaw;
            /**
             * Gets the GPS refresh rate, in seconds.
             * @returns The GPS refresh rate, or 0 if no fixed rate is used.
             */
            get_gps_refresh_rate(): number;
            /**
             * Gets the DBus path of the #MMObject which implements this interface.
             * @returns The DBus path of the #MMObject object.
             */
            get_path(): string;
            /**
             * Gets a #MMLocation3gpp object with the current 3GPP location information.
             *
             * Unlike mm_modem_location_get_3gpp() or mm_modem_location_get_3gpp_sync(),
             * this method does not perform an explicit query. Instead, this method will
             * return the location information that may have been signaled by the modem.
             * Therefore, this method will only succeed if location signaling is enabled
             * (e.g. with mm_modem_location_setup() in the #MMModemLocation).
             *
             * <warning>The values reported by `self` are not updated when the values in the
             * interface change. Instead, the client is expected to call
             * mm_modem_location_get_signaled_3gpp() again to get a new #MMLocation3gpp
             * with the new values.</warning>
             * @returns A #MMLocation3gpp that must be freed with g_object_unref() or %NULL if none available.
             */
            get_signaled_3gpp(): Location3gpp;
            /**
             * Gets a #MMLocationCdmaBs object with the current CDMA base station location
             * information.
             *
             * Unlike mm_modem_location_get_cdma_bs() or
             * mm_modem_location_get_cdma_bs_sync(), this method does not perform an
             * explicit query. Instead, this method will return the location information
             * that may have been signaled by the modem. Therefore, this method will only
             * succeed if location signaling is enabled (e.g. with mm_modem_location_setup()
             * in the #MMModemLocation).
             *
             * <warning>The values reported by `self` are not updated when the values in the
             * interface change. Instead, the client is expected to call
             * mm_modem_location_get_signaled_cdma_bs() again to get a new #MMLocationCdmaBs
             * with the new values.</warning>
             * @returns A #MMLocationCdmaBs that must be freed with g_object_unref() or %NULL if none available.
             */
            get_signaled_cdma_bs(): LocationCdmaBs;
            /**
             * Gets a #MMLocationGpsNmea object with the current GPS NMEA location
             * information.
             *
             * Unlike mm_modem_location_get_gps_nmea() or
             * mm_modem_location_get_gps_nmea_sync(), this method does not perform an
             * explicit query. Instead, this method will return the location information
             * that may have been signaled by the modem. Therefore, this method will only
             * succeed if location signaling is enabled (e.g. with mm_modem_location_setup()
             * in the #MMModemLocation).
             *
             * <warning>The values reported by `self` are not updated when the values in the
             * interface change. Instead, the client is expected to call
             * mm_modem_location_get_signaled_gps_nmea() again to get a new #MMLocationGpsNmea
             * with the new values.</warning>
             * @returns A #MMLocationGpsNmea that must be freed with g_object_unref() or %NULL if none available.
             */
            get_signaled_gps_nmea(): LocationGpsNmea;
            /**
             * Gets a #MMLocationGpsRaw object with the current GPS raw location
             * information.
             *
             * Unlike mm_modem_location_get_gps_raw() or
             * mm_modem_location_get_gps_raw_sync(), this method does not perform an
             * explicit query. Instead, this method will return the location information
             * that may have been signaled by the modem. Therefore, this method will only
             * succeed if location signaling is enabled (e.g. with mm_modem_location_setup()
             * in the #MMModemLocation).
             *
             * <warning>The values reported by `self` are not updated when the values in the
             * interface change. Instead, the client is expected to call
             * mm_modem_location_get_signaled_gps_raw() again to get a new #MMLocationGpsRaw
             * with the new values.</warning>
             * @returns A #MMLocationGpsRaw that must be freed with g_object_unref() or %NULL if none available.
             */
            get_signaled_gps_raw(): LocationGpsRaw;
            /**
             * Gets the address of the SUPL server.
             *
             * <warning>The returned value is only valid until the property changes so it is
             * only safe to use this function on the thread where `self` was constructed. Use
             * mm_modem_location_dup_supl_server() if on another thread.</warning>
             * @returns The SUPL server address, or %NULL if none available. Do not free the returned value, it belongs to @self.
             */
            get_supl_server(): string;
            /**
             * Gets a bitmask of the supported assistance data types.
             * @returns A #MMModemLocationAssistanceDataType.
             */
            get_supported_assistance_data(): ModemLocationAssistanceDataType;
            /**
             * Aynchronously injects assistance data to the GNSS module.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_location_inject_assistance_data_finish() to get the result of the
             * operation.
             *
             * See mm_modem_location_inject_assistance_data_sync() for the synchronous,
             * blocking version of this method.
             * @param data Data to inject.
             * @param cancellable A #GCancellable or %NULL.
             */
            inject_assistance_data(data: Uint8Array | string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Aynchronously injects assistance data to the GNSS module.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_location_inject_assistance_data_finish() to get the result of the
             * operation.
             *
             * See mm_modem_location_inject_assistance_data_sync() for the synchronous,
             * blocking version of this method.
             * @param data Data to inject.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            inject_assistance_data(
                data: Uint8Array | string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Aynchronously injects assistance data to the GNSS module.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_location_inject_assistance_data_finish() to get the result of the
             * operation.
             *
             * See mm_modem_location_inject_assistance_data_sync() for the synchronous,
             * blocking version of this method.
             * @param data Data to inject.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            inject_assistance_data(
                data: Uint8Array | string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with
             * mm_modem_location_inject_assistance_data().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_location_inject_assistance_data().
             * @returns %TRUE if the injection was successful, %FALSE if @error is set.
             */
            inject_assistance_data_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously injects assistance data to the GNSS module.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_location_inject_assistance_data() for the asynchronous version of
             * this method.
             * @param data Data to inject.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the injection was successful, %FALSE if @error is set.
             */
            inject_assistance_data_sync(data: Uint8Array | string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Gets a #MMLocation3gpp object with the current 3GPP location information.
             *
             * Unlike mm_modem_location_get_3gpp() or mm_modem_location_get_3gpp_sync(),
             * this method does not perform an explicit query. Instead, this method will
             * return the location information that may have been signaled by the modem.
             * Therefore, this method will only succeed if location signaling is enabled
             * (e.g. with mm_modem_location_setup() in the #MMModemLocation).
             *
             * <warning>The returned value is only valid until the property changes so
             * it is only safe to use this function on the thread where
             * `self` was constructed. Use mm_modem_location_get_signaled_3gpp() if on
             * another thread.</warning>
             * @returns A #MMLocation3gpp, or %NULL if none available. Do not free the returned value, it belongs to @self.
             */
            peek_signaled_3gpp(): Location3gpp;
            /**
             * Gets a #MMLocationCdmaBs object with the current CDMA base station location
             * information.
             *
             * Unlike mm_modem_location_get_cdma_bs() or
             * mm_modem_location_get_cdma_bs_sync(), this method does not perform an
             * explicit query. Instead, this method will return the location information
             * that may have been signaled by the modem. Therefore, this method will only
             * succeed if location signaling is enabled (e.g. with mm_modem_location_setup()
             * in the #MMModemLocation).
             *
             * <warning>The returned value is only valid until the property changes so
             * it is only safe to use this function on the thread where
             * `self` was constructed. Use mm_modem_location_get_signaled_cdma_bs() if on
             * another thread.</warning>
             * @returns A #MMLocationCdmaBs, or %NULL if none available. Do not free the returned value, it belongs to @self.
             */
            peek_signaled_cdma_bs(): LocationCdmaBs;
            /**
             * Gets a #MMLocationGpsNmea object with the current GPS NMEA location
             * information.
             *
             * Unlike mm_modem_location_get_gps_nmea() or
             * mm_modem_location_get_gps_nmea_sync(), this method does not perform an
             * explicit query. Instead, this method will return the location information
             * that may have been signaled by the modem. Therefore, this method will only
             * succeed if location signaling is enabled (e.g. with mm_modem_location_setup()
             * in the #MMModemLocation).
             *
             * <warning>The returned value is only valid until the property changes so
             * it is only safe to use this function on the thread where
             * `self` was constructed. Use mm_modem_location_get_signaled_gps_nmea() if on
             * another thread.</warning>
             * @returns A #MMLocationGpsNmea, or %NULL if none available. Do not free the returned value, it belongs to @self.
             */
            peek_signaled_gps_nmea(): LocationGpsNmea;
            /**
             * Gets a #MMLocationGpsRaw object with the current GPS raw location
             * information.
             *
             * Unlike mm_modem_location_get_gps_raw() or
             * mm_modem_location_get_gps_raw_sync(), this method does not perform an
             * explicit query. Instead, this method will return the location information
             * that may have been signaled by the modem. Therefore, this method will only
             * succeed if location signaling is enabled (e.g. with mm_modem_location_setup()
             * in the #MMModemLocation).
             *
             * <warning>The returned value is only valid until the property changes so
             * it is only safe to use this function on the thread where
             * `self` was constructed. Use mm_modem_location_get_signaled_gps_raw() if on
             * another thread.</warning>
             * @returns A #MMLocationGpsRaw, or %NULL if none available. Do not free the returned value, it belongs to @self.
             */
            peek_signaled_gps_raw(): LocationGpsRaw;
            /**
             * Asynchronously configures the GPS refresh rate.
             *
             * If a 0 rate is used, the GPS location updates will be immediately propagated
             * to the interface.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_location_set_gps_refresh_rate_finish() to get the result of the
             * operation.
             *
             * See mm_modem_location_set_gps_refresh_rate_sync() for the synchronous,
             * blocking version of this method.
             * @param rate The GPS refresh rate, in seconds.
             * @param cancellable A #GCancellable or %NULL.
             */
            set_gps_refresh_rate(rate: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously configures the GPS refresh rate.
             *
             * If a 0 rate is used, the GPS location updates will be immediately propagated
             * to the interface.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_location_set_gps_refresh_rate_finish() to get the result of the
             * operation.
             *
             * See mm_modem_location_set_gps_refresh_rate_sync() for the synchronous,
             * blocking version of this method.
             * @param rate The GPS refresh rate, in seconds.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            set_gps_refresh_rate(
                rate: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously configures the GPS refresh rate.
             *
             * If a 0 rate is used, the GPS location updates will be immediately propagated
             * to the interface.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_location_set_gps_refresh_rate_finish() to get the result of the
             * operation.
             *
             * See mm_modem_location_set_gps_refresh_rate_sync() for the synchronous,
             * blocking version of this method.
             * @param rate The GPS refresh rate, in seconds.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            set_gps_refresh_rate(
                rate: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_modem_location_set_gps_refresh_rate().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_location_set_gps_refresh_rate().
             * @returns %TRUE if setting the GPS refresh rate was successful, %FALSE if @error is set.
             */
            set_gps_refresh_rate_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously configures the GPS refresh rate.
             *
             * If a 0 rate is used, the GPS location updates will be immediately propagated
             * to the interface.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_location_set_gps_refresh_rate() for the asynchronous version of this
             * method.
             * @param rate The GPS refresh rate, in seconds.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if setting the refresh rate was successful, %FALSE if @error is set.
             */
            set_gps_refresh_rate_sync(rate: number, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously configures the address of the SUPL server for A-GPS operation.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_location_set_supl_server_finish() to get the result of the operation.
             *
             * See mm_modem_location_set_supl_server_sync() for the synchronous, blocking
             * version of this method.
             * @param supl The SUPL server address, given as IP:PORT or with a full URL.
             * @param cancellable A #GCancellable or %NULL.
             */
            set_supl_server(supl: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously configures the address of the SUPL server for A-GPS operation.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_location_set_supl_server_finish() to get the result of the operation.
             *
             * See mm_modem_location_set_supl_server_sync() for the synchronous, blocking
             * version of this method.
             * @param supl The SUPL server address, given as IP:PORT or with a full URL.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            set_supl_server(
                supl: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously configures the address of the SUPL server for A-GPS operation.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_location_set_supl_server_finish() to get the result of the operation.
             *
             * See mm_modem_location_set_supl_server_sync() for the synchronous, blocking
             * version of this method.
             * @param supl The SUPL server address, given as IP:PORT or with a full URL.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            set_supl_server(
                supl: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_modem_location_set_supl_server().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_location_set_supl_server().
             * @returns %TRUE if setting the SUPL server was successful, %FALSE if @error is set.
             */
            set_supl_server_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously configures the address of the SUPL server for A-GPS operation.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_location_set_supl_server() for the asynchronous version of this
             * method.
             * @param supl The SUPL server address, given as IP:PORT or with a full URL.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if setting the SUPL server was successful, %FALSE if @error is set.
             */
            set_supl_server_sync(supl: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously configures the location sources to use when gathering location
             * information. Also enable or disable location information gathering.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_location_setup_finish() to get the result of the operation.
             *
             * See mm_modem_location_setup_sync() for the synchronous, blocking version of
             * this method.
             * @param sources Bitmask of #MMModemLocationSource values specifying which locations  should get enabled.
             * @param signal_location Flag to enable or disable location signaling.
             * @param cancellable A #GCancellable or %NULL.
             */
            setup(
                sources: ModemLocationSource | null,
                signal_location: boolean,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronously configures the location sources to use when gathering location
             * information. Also enable or disable location information gathering.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_location_setup_finish() to get the result of the operation.
             *
             * See mm_modem_location_setup_sync() for the synchronous, blocking version of
             * this method.
             * @param sources Bitmask of #MMModemLocationSource values specifying which locations  should get enabled.
             * @param signal_location Flag to enable or disable location signaling.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            setup(
                sources: ModemLocationSource | null,
                signal_location: boolean,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously configures the location sources to use when gathering location
             * information. Also enable or disable location information gathering.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_location_setup_finish() to get the result of the operation.
             *
             * See mm_modem_location_setup_sync() for the synchronous, blocking version of
             * this method.
             * @param sources Bitmask of #MMModemLocationSource values specifying which locations  should get enabled.
             * @param signal_location Flag to enable or disable location signaling.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            setup(
                sources: ModemLocationSource | null,
                signal_location: boolean,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_modem_location_setup().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_modem_location_setup().
             * @returns %TRUE if the setup was successful, %FALSE if @error is set.
             */
            setup_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously configures the location sources to use when gathering location
             * information. Also enable or disable location information gathering.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_location_setup() for the asynchronous version of this method.
             * @param sources Bitmask of #MMModemLocationSource values specifying which locations  should get enabled.
             * @param signal_location Flag to enable or disable location signaling.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the setup was successful, %FALSE if @error is set.
             */
            setup_sync(
                sources: ModemLocationSource | null,
                signal_location: boolean,
                cancellable?: Gio.Cancellable | null,
            ): boolean;

            // Inherited properties
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Location.AssistanceDataServers">"AssistanceDataServers"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get assistance_data_servers(): string[];
            set assistance_data_servers(val: string[]);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Location.AssistanceDataServers">"AssistanceDataServers"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get assistanceDataServers(): string[];
            set assistanceDataServers(val: string[]);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Location.Capabilities">"Capabilities"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get capabilities(): number;
            set capabilities(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Location.Enabled">"Enabled"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get enabled(): number;
            set enabled(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Location.GpsRefreshRate">"GpsRefreshRate"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get gps_refresh_rate(): number;
            set gps_refresh_rate(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Location.GpsRefreshRate">"GpsRefreshRate"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get gpsRefreshRate(): number;
            set gpsRefreshRate(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Location.Location">"Location"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get location(): GLib.Variant;
            set location(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Location.SignalsLocation">"SignalsLocation"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get signalsLocation(): boolean;
            set signalsLocation(val: boolean);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Location.SuplServer">"SuplServer"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get supl_server(): string;
            set supl_server(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Location.SuplServer">"SuplServer"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get suplServer(): string;
            set suplServer(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Location.SupportedAssistanceData">"SupportedAssistanceData"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get supported_assistance_data(): number;
            set supported_assistance_data(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Location.SupportedAssistanceData">"SupportedAssistanceData"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get supportedAssistanceData(): number;
            set supportedAssistanceData(val: number);

            // Inherited methods
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            init_async(io_priority: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             * @returns %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present.
             */
            init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Finishes the async construction for the various g_async_initable_new
             * calls, returning the created object or %NULL on error.
             * @param res the #GAsyncResult from the callback
             * @returns a newly created #GObject,      or %NULL on error. Free with g_object_unref().
             */
            new_finish(res: Gio.AsyncResult): ModemLocation;
            // Conflicted with ModemManager.GdbusModemLocationProxy.new_finish
            new_finish(...args: never[]): any;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            vfunc_init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             */
            vfunc_init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.GetLocation">GetLocation()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_call_get_location_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_call_get_location_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_get_location(cancellable?: Gio.Cancellable | null): Promise<GLib.Variant | null>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.GetLocation">GetLocation()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_call_get_location_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_call_get_location_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_get_location(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.GetLocation">GetLocation()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_call_get_location_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_call_get_location_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_get_location(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<GLib.Variant | null> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_location_call_get_location().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_location_call_get_location().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_get_location_finish(res: Gio.AsyncResult): [boolean, GLib.Variant | null];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.GetLocation">GetLocation()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_location_call_get_location() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_get_location_sync(cancellable?: Gio.Cancellable | null): [boolean, GLib.Variant | null];
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.InjectAssistanceData">InjectAssistanceData()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_call_inject_assistance_data_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_call_inject_assistance_data_sync() for the synchronous, blocking version of this method.
             * @param arg_data Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_inject_assistance_data(arg_data: GLib.Variant, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.InjectAssistanceData">InjectAssistanceData()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_call_inject_assistance_data_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_call_inject_assistance_data_sync() for the synchronous, blocking version of this method.
             * @param arg_data Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_inject_assistance_data(
                arg_data: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.InjectAssistanceData">InjectAssistanceData()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_call_inject_assistance_data_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_call_inject_assistance_data_sync() for the synchronous, blocking version of this method.
             * @param arg_data Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_inject_assistance_data(
                arg_data: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_location_call_inject_assistance_data().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_location_call_inject_assistance_data().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_inject_assistance_data_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.InjectAssistanceData">InjectAssistanceData()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_location_call_inject_assistance_data() for the asynchronous version of this method.
             * @param arg_data Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_inject_assistance_data_sync(arg_data: GLib.Variant, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.SetGpsRefreshRate">SetGpsRefreshRate()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_call_set_gps_refresh_rate_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_call_set_gps_refresh_rate_sync() for the synchronous, blocking version of this method.
             * @param arg_rate Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set_gps_refresh_rate(arg_rate: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.SetGpsRefreshRate">SetGpsRefreshRate()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_call_set_gps_refresh_rate_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_call_set_gps_refresh_rate_sync() for the synchronous, blocking version of this method.
             * @param arg_rate Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_gps_refresh_rate(
                arg_rate: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.SetGpsRefreshRate">SetGpsRefreshRate()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_call_set_gps_refresh_rate_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_call_set_gps_refresh_rate_sync() for the synchronous, blocking version of this method.
             * @param arg_rate Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_gps_refresh_rate(
                arg_rate: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_location_call_set_gps_refresh_rate().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_location_call_set_gps_refresh_rate().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_gps_refresh_rate_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.SetGpsRefreshRate">SetGpsRefreshRate()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_location_call_set_gps_refresh_rate() for the asynchronous version of this method.
             * @param arg_rate Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_gps_refresh_rate_sync(arg_rate: number, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.SetSuplServer">SetSuplServer()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_call_set_supl_server_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_call_set_supl_server_sync() for the synchronous, blocking version of this method.
             * @param arg_supl Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set_supl_server(arg_supl: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.SetSuplServer">SetSuplServer()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_call_set_supl_server_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_call_set_supl_server_sync() for the synchronous, blocking version of this method.
             * @param arg_supl Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_supl_server(
                arg_supl: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.SetSuplServer">SetSuplServer()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_call_set_supl_server_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_call_set_supl_server_sync() for the synchronous, blocking version of this method.
             * @param arg_supl Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_supl_server(
                arg_supl: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_location_call_set_supl_server().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_location_call_set_supl_server().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_supl_server_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.SetSuplServer">SetSuplServer()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_location_call_set_supl_server() for the asynchronous version of this method.
             * @param arg_supl Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_supl_server_sync(arg_supl: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.Setup">Setup()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_call_setup_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_call_setup_sync() for the synchronous, blocking version of this method.
             * @param arg_sources Argument to pass with the method invocation.
             * @param arg_signal_location Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_setup(
                arg_sources: number,
                arg_signal_location: boolean,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.Setup">Setup()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_call_setup_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_call_setup_sync() for the synchronous, blocking version of this method.
             * @param arg_sources Argument to pass with the method invocation.
             * @param arg_signal_location Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_setup(
                arg_sources: number,
                arg_signal_location: boolean,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.Setup">Setup()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_call_setup_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_call_setup_sync() for the synchronous, blocking version of this method.
             * @param arg_sources Argument to pass with the method invocation.
             * @param arg_signal_location Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_setup(
                arg_sources: number,
                arg_signal_location: boolean,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_location_call_setup().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_location_call_setup().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_setup_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.Setup">Setup()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_location_call_setup() for the asynchronous version of this method.
             * @param arg_sources Argument to pass with the method invocation.
             * @param arg_signal_location Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_setup_sync(
                arg_sources: number,
                arg_signal_location: boolean,
                cancellable?: Gio.Cancellable | null,
            ): boolean;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.GetLocation">GetLocation()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param Location Parameter to return.
             */
            complete_get_location(invocation: Gio.DBusMethodInvocation, Location: GLib.Variant): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.InjectAssistanceData">InjectAssistanceData()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_inject_assistance_data(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.SetGpsRefreshRate">SetGpsRefreshRate()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_set_gps_refresh_rate(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.SetSuplServer">SetSuplServer()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_set_supl_server(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.Setup">Setup()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_setup(invocation: Gio.DBusMethodInvocation): void;
            vfunc_handle_get_location(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_inject_assistance_data(invocation: Gio.DBusMethodInvocation, arg_data: GLib.Variant): boolean;
            vfunc_handle_set_gps_refresh_rate(invocation: Gio.DBusMethodInvocation, arg_rate: number): boolean;
            vfunc_handle_set_supl_server(invocation: Gio.DBusMethodInvocation, arg_supl: string): boolean;
            vfunc_handle_setup(
                invocation: Gio.DBusMethodInvocation,
                arg_sources: number,
                arg_signal_location: boolean,
            ): boolean;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace ModemMessaging {
            // Constructor properties interface

            interface ConstructorProps
                extends GdbusModemMessagingProxy.ConstructorProps,
                    Gio.AsyncInitable.ConstructorProps,
                    Gio.DBusInterface.ConstructorProps,
                    Gio.Initable.ConstructorProps,
                    GdbusModemMessaging.ConstructorProps {}
        }

        /**
         * The #MMModemMessaging structure contains private data and should only be accessed
         * using the provided API.
         */
        class ModemMessaging
            extends GdbusModemMessagingProxy
            implements Gio.AsyncInitable<ModemMessaging>, Gio.DBusInterface, Gio.Initable, GdbusModemMessaging
        {
            static $gtype: GObject.GType<ModemMessaging>;

            // Constructors

            constructor(properties?: Partial<ModemMessaging.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Methods

            /**
             * Asynchronously creates a new #MMSms in the modem.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_messaging_create_finish() to get the result of the operation.
             *
             * See mm_modem_messaging_create_sync() for the synchronous, blocking version of
             * this method.
             * @param properties A ##MMSmsProperties object with the properties to use.
             * @param cancellable A #GCancellable or %NULL.
             */
            create(properties: SmsProperties, cancellable?: Gio.Cancellable | null): Promise<Sms>;
            /**
             * Asynchronously creates a new #MMSms in the modem.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_messaging_create_finish() to get the result of the operation.
             *
             * See mm_modem_messaging_create_sync() for the synchronous, blocking version of
             * this method.
             * @param properties A ##MMSmsProperties object with the properties to use.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            create(
                properties: SmsProperties,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously creates a new #MMSms in the modem.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_messaging_create_finish() to get the result of the operation.
             *
             * See mm_modem_messaging_create_sync() for the synchronous, blocking version of
             * this method.
             * @param properties A ##MMSmsProperties object with the properties to use.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            create(
                properties: SmsProperties,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<Sms> | void;
            /**
             * Finishes an operation started with mm_modem_messaging_create().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_messaging_create().
             * @returns A newly created #MMSms, or %NULL if @error is set. The returned value should be freed with g_object_unref().
             */
            create_finish(res: Gio.AsyncResult): Sms;
            /**
             * Synchronously creates a new #MMSms in the modem.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_messaging_create() for the asynchronous version of this method.
             * @param properties A ##MMSmsProperties object with the properties to use.
             * @param cancellable A #GCancellable or %NULL.
             * @returns A newly created #MMSms, or %NULL if @error is set. The returned value should be freed with g_object_unref().
             */
            create_sync(properties: SmsProperties, cancellable?: Gio.Cancellable | null): Sms;
            /**
             * Asynchronously deletes a given #MMSms from the modem.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_messaging_delete_finish() to get the result of the operation.
             *
             * See mm_modem_messaging_delete_sync() for the synchronous, blocking version
             * of this method.
             * @param sms Path of the #MMSms to delete.
             * @param cancellable A #GCancellable or %NULL.
             */
            ['delete'](sms: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously deletes a given #MMSms from the modem.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_messaging_delete_finish() to get the result of the operation.
             *
             * See mm_modem_messaging_delete_sync() for the synchronous, blocking version
             * of this method.
             * @param sms Path of the #MMSms to delete.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            ['delete'](
                sms: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously deletes a given #MMSms from the modem.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_messaging_delete_finish() to get the result of the operation.
             *
             * See mm_modem_messaging_delete_sync() for the synchronous, blocking version
             * of this method.
             * @param sms Path of the #MMSms to delete.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            ['delete'](
                sms: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_modem_messaging_delete().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_messaging_delete().
             * @returns %TRUE if the sms was deleted, %FALSE if @error is set.
             */
            delete_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously deletes a given #MMSms from the modem.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_messaging_delete() for the asynchronous version of this method.
             * @param sms Path of the #MMSms to delete.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the SMS was deleted, %FALSE if @error is set.
             */
            delete_sync(sms: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Gets a copy of the DBus path of the #MMObject object which implements this
             * interface.
             * @returns The DBus path of the #MMObject. The returned value should be freed with g_free().
             */
            dup_path(): string;
            /**
             * Gets the default SMS storage used when storing or receiving SMS messages.
             * @returns the default #MMSmsStorage.
             */
            get_default_storage(): SmsStorage;
            /**
             * Gets the DBus path of the #MMObject which implements this interface.
             * @returns The DBus path of the #MMObject object.
             */
            get_path(): string;
            /**
             * Gets the list of SMS storages supported by the #MMModem.
             * @returns %TRUE if @storages and @n_storages are set, %FALSE otherwise.
             */
            get_supported_storages(): [boolean, SmsStorage[]];
            /**
             * Asynchronously lists the #MMSms objects in the modem.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_messaging_list_finish() to get the result of the operation.
             *
             * See mm_modem_messaging_list_sync() for the synchronous, blocking version of
             * this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            list(cancellable?: Gio.Cancellable | null): Promise<Sms[]>;
            /**
             * Asynchronously lists the #MMSms objects in the modem.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_messaging_list_finish() to get the result of the operation.
             *
             * See mm_modem_messaging_list_sync() for the synchronous, blocking version of
             * this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            list(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously lists the #MMSms objects in the modem.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_messaging_list_finish() to get the result of the operation.
             *
             * See mm_modem_messaging_list_sync() for the synchronous, blocking version of
             * this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            list(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<Sms[]> | void;
            /**
             * Finishes an operation started with mm_modem_messaging_list().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_messaging_list().
             * @returns A list of #MMSms objects, or #NULL if either not found or @error is set. The returned value should be freed with g_list_free_full() using g_object_unref() as #GDestroyNotify function.
             */
            list_finish(res: Gio.AsyncResult): Sms[];
            /**
             * Synchronously lists the #MMSms objects in the modem.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_messaging_list() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns A list of #MMSms objects, or #NULL if either not found or @error is set. The returned value should be freed with g_list_free_full() using g_object_unref() as #GDestroyNotify function.
             */
            list_sync(cancellable?: Gio.Cancellable | null): Sms[];
            /**
             * Gets the list of SMS storages supported by the #MMModem.
             * @returns %TRUE if @storages and @n_storages are set, %FALSE otherwise.
             */
            peek_supported_storages(): [boolean, SmsStorage, number];

            // Inherited properties
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Messaging.DefaultStorage">"DefaultStorage"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get default_storage(): number;
            set default_storage(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Messaging.DefaultStorage">"DefaultStorage"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get defaultStorage(): number;
            set defaultStorage(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Messaging.Messages">"Messages"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get messages(): string[];
            set messages(val: string[]);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Messaging.SupportedStorages">"SupportedStorages"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get supported_storages(): GLib.Variant;
            set supported_storages(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Messaging.SupportedStorages">"SupportedStorages"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get supportedStorages(): GLib.Variant;
            set supportedStorages(val: GLib.Variant);

            // Inherited methods
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            init_async(io_priority: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             * @returns %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present.
             */
            init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Finishes the async construction for the various g_async_initable_new
             * calls, returning the created object or %NULL on error.
             * @param res the #GAsyncResult from the callback
             * @returns a newly created #GObject,      or %NULL on error. Free with g_object_unref().
             */
            new_finish(res: Gio.AsyncResult): ModemMessaging;
            // Conflicted with ModemManager.GdbusModemMessagingProxy.new_finish
            new_finish(...args: never[]): any;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            vfunc_init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             */
            vfunc_init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Messaging.Create">Create()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_messaging_call_create_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_messaging_call_create_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_create(arg_properties: GLib.Variant, cancellable?: Gio.Cancellable | null): Promise<string>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Messaging.Create">Create()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_messaging_call_create_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_messaging_call_create_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_create(
                arg_properties: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Messaging.Create">Create()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_messaging_call_create_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_messaging_call_create_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_create(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<string> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_messaging_call_create().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_messaging_call_create().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_create_finish(res: Gio.AsyncResult): [boolean, string];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Messaging.Create">Create()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_messaging_call_create() for the asynchronous version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_create_sync(arg_properties: GLib.Variant, cancellable?: Gio.Cancellable | null): [boolean, string];
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Messaging.Delete">Delete()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_messaging_call_delete_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_messaging_call_delete_sync() for the synchronous, blocking version of this method.
             * @param arg_path Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_delete(arg_path: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Messaging.Delete">Delete()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_messaging_call_delete_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_messaging_call_delete_sync() for the synchronous, blocking version of this method.
             * @param arg_path Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_delete(
                arg_path: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Messaging.Delete">Delete()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_messaging_call_delete_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_messaging_call_delete_sync() for the synchronous, blocking version of this method.
             * @param arg_path Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_delete(
                arg_path: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_messaging_call_delete().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_messaging_call_delete().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_delete_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Messaging.Delete">Delete()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_messaging_call_delete() for the asynchronous version of this method.
             * @param arg_path Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_delete_sync(arg_path: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Messaging.List">List()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_messaging_call_list_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_messaging_call_list_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_list(cancellable?: Gio.Cancellable | null): Promise<string[] | null>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Messaging.List">List()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_messaging_call_list_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_messaging_call_list_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_list(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Messaging.List">List()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_messaging_call_list_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_messaging_call_list_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_list(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<string[] | null> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_messaging_call_list().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_messaging_call_list().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_list_finish(res: Gio.AsyncResult): [boolean, string[] | null];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Messaging.List">List()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_messaging_call_list() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_list_sync(cancellable?: Gio.Cancellable | null): [boolean, string[] | null];
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Messaging.Create">Create()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param path Parameter to return.
             */
            complete_create(invocation: Gio.DBusMethodInvocation, path: string): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Messaging.Delete">Delete()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_delete(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Messaging.List">List()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param result Parameter to return.
             */
            complete_list(invocation: Gio.DBusMethodInvocation, result: string): void;
            /**
             * Emits the <link linkend="gdbus-signal-org-freedesktop-ModemManager1-Modem-Messaging.Added">"Added"</link> D-Bus signal.
             * @param arg_path Argument to pass with the signal.
             * @param arg_received Argument to pass with the signal.
             */
            emit_added(arg_path: string, arg_received: boolean): void;
            /**
             * Emits the <link linkend="gdbus-signal-org-freedesktop-ModemManager1-Modem-Messaging.Deleted">"Deleted"</link> D-Bus signal.
             * @param arg_path Argument to pass with the signal.
             */
            emit_deleted(arg_path: string): void;
            vfunc_added(arg_path: string, arg_received: boolean): void;
            vfunc_deleted(arg_path: string): void;
            vfunc_handle_create(invocation: Gio.DBusMethodInvocation, arg_properties: GLib.Variant): boolean;
            vfunc_handle_delete(invocation: Gio.DBusMethodInvocation, arg_path: string): boolean;
            vfunc_handle_list(invocation: Gio.DBusMethodInvocation): boolean;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace ModemOma {
            // Constructor properties interface

            interface ConstructorProps
                extends GdbusModemOmaProxy.ConstructorProps,
                    Gio.AsyncInitable.ConstructorProps,
                    Gio.DBusInterface.ConstructorProps,
                    Gio.Initable.ConstructorProps,
                    GdbusModemOma.ConstructorProps {}
        }

        /**
         * The #MMModemOma structure contains private data and should only be accessed
         * using the provided API.
         */
        class ModemOma
            extends GdbusModemOmaProxy
            implements Gio.AsyncInitable<ModemOma>, Gio.DBusInterface, Gio.Initable, GdbusModemOma
        {
            static $gtype: GObject.GType<ModemOma>;

            // Constructors

            constructor(properties?: Partial<ModemOma.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Methods

            /**
             * Asynchronously accepts a nework-initiated OMA device management session.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_oma_accept_network_initiated_session_finish() to get the result of
             * the operation.
             *
             * See mm_modem_oma_accept_network_initiated_session_sync() for the synchronous,
             * blocking version of this method.
             * @param session_id The unique ID of the network-initiated session.
             * @param accept %TRUE if the session is to be accepted, %FALSE otherwise.
             * @param cancellable A #GCancellable or %NULL.
             */
            accept_network_initiated_session(
                session_id: number,
                accept: boolean,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronously accepts a nework-initiated OMA device management session.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_oma_accept_network_initiated_session_finish() to get the result of
             * the operation.
             *
             * See mm_modem_oma_accept_network_initiated_session_sync() for the synchronous,
             * blocking version of this method.
             * @param session_id The unique ID of the network-initiated session.
             * @param accept %TRUE if the session is to be accepted, %FALSE otherwise.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            accept_network_initiated_session(
                session_id: number,
                accept: boolean,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously accepts a nework-initiated OMA device management session.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_oma_accept_network_initiated_session_finish() to get the result of
             * the operation.
             *
             * See mm_modem_oma_accept_network_initiated_session_sync() for the synchronous,
             * blocking version of this method.
             * @param session_id The unique ID of the network-initiated session.
             * @param accept %TRUE if the session is to be accepted, %FALSE otherwise.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            accept_network_initiated_session(
                session_id: number,
                accept: boolean,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with
             * mm_modem_oma_accept_network_initiated_session().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_oma_accept_network_initiated_session().
             * @returns %TRUE if the session was started, %FALSE if @error is set.
             */
            accept_network_initiated_session_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously accepts a nework-initiated OMA device management session.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_oma_accept_network_initiated_session() for the asynchronous version
             * of this method.
             * @param session_id The unique ID of the network-initiated session.
             * @param accept %TRUE if the session is to be accepted, %FALSE otherwise.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the session was started, %FALSE if @error is set.
             */
            accept_network_initiated_session_sync(
                session_id: number,
                accept: boolean,
                cancellable?: Gio.Cancellable | null,
            ): boolean;
            /**
             * Asynchronously cancels the current OMA device management session.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_oma_cancel_session_finish() to get the result of the operation.
             *
             * See mm_modem_oma_cancel_session_sync() for the synchronous, blocking version
             * of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            cancel_session(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously cancels the current OMA device management session.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_oma_cancel_session_finish() to get the result of the operation.
             *
             * See mm_modem_oma_cancel_session_sync() for the synchronous, blocking version
             * of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            cancel_session(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously cancels the current OMA device management session.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_oma_cancel_session_finish() to get the result of the operation.
             *
             * See mm_modem_oma_cancel_session_sync() for the synchronous, blocking version
             * of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            cancel_session(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_modem_oma_cancel_session().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_oma_cancel_session().
             * @returns %TRUE if the session was started, %FALSE if @error is set.
             */
            cancel_session_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously cancels the current OMA device management session.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_oma_cancel_session() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the session was started, %FALSE if @error is set.
             */
            cancel_session_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Gets a copy of the DBus path of the #MMObject object which implements this
             * interface.
             * @returns The DBus path of the #MMObject. The returned value should be freed with g_free().
             */
            dup_path(): string;
            /**
             * Gets the currently enabled OMA features.
             * @returns a bitmask of #MMOmaFeature values.
             */
            get_features(): OmaFeature;
            /**
             * Gets the DBus path of the #MMObject which implements this interface.
             * @returns The DBus path of the #MMObject object.
             */
            get_path(): string;
            /**
             * Gets the list of pending network-initiated OMA sessions.
             * @returns %TRUE if @sessions and @n_sessions are set, %FALSE otherwise.
             */
            get_pending_network_initiated_sessions(): [boolean, OmaPendingNetworkInitiatedSession[]];
            /**
             * Gets the state of the current OMA device management session.
             * @returns a #MMOmaSessionState.
             */
            get_session_state(): OmaSessionState;
            /**
             * Gets the type of the current OMA device management session.
             * @returns a #MMOmaSessionType.
             */
            get_session_type(): OmaSessionType;
            /**
             * Gets the list of pending network-initiated OMA sessions.
             * @returns %TRUE if @sessions and @n_sessions are set, %FALSE otherwise.
             */
            peek_pending_network_initiated_sessions(): [boolean, OmaPendingNetworkInitiatedSession[]];
            /**
             * Asynchronously sets up the OMA device management service.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_oma_setup_finish() to get the result of the operation.
             *
             * See mm_modem_oma_setup_sync() for the synchronous, blocking version of this
             * method.
             * @param features Mask of #MMOmaFeature values to enable.
             * @param cancellable A #GCancellable or %NULL.
             */
            setup(features: OmaFeature | null, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously sets up the OMA device management service.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_oma_setup_finish() to get the result of the operation.
             *
             * See mm_modem_oma_setup_sync() for the synchronous, blocking version of this
             * method.
             * @param features Mask of #MMOmaFeature values to enable.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            setup(
                features: OmaFeature | null,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously sets up the OMA device management service.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_oma_setup_finish() to get the result of the operation.
             *
             * See mm_modem_oma_setup_sync() for the synchronous, blocking version of this
             * method.
             * @param features Mask of #MMOmaFeature values to enable.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            setup(
                features: OmaFeature | null,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_modem_oma_setup().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_oma_setup().
             * @returns %TRUE if the setup was successful, %FALSE if @error is set.
             */
            setup_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously sets up the OMA device management service.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_oma_setup() for the asynchronous version of this method.
             * @param features Mask of #MMOmaFeature values to enable.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the setup was successful, %FALSE if @error is set.
             */
            setup_sync(features: OmaFeature | null, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously starts a client-initiated OMA device management session.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_oma_start_client_initiated_session_finish() to get the result of the
             * operation.
             *
             * See mm_modem_oma_start_client_initiated_session_sync() for the synchronous,
             * blocking version of this method.
             * @param session_type A #MMOmaSessionType.
             * @param cancellable A #GCancellable or %NULL.
             */
            start_client_initiated_session(
                session_type: OmaSessionType | null,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronously starts a client-initiated OMA device management session.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_oma_start_client_initiated_session_finish() to get the result of the
             * operation.
             *
             * See mm_modem_oma_start_client_initiated_session_sync() for the synchronous,
             * blocking version of this method.
             * @param session_type A #MMOmaSessionType.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            start_client_initiated_session(
                session_type: OmaSessionType | null,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously starts a client-initiated OMA device management session.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_oma_start_client_initiated_session_finish() to get the result of the
             * operation.
             *
             * See mm_modem_oma_start_client_initiated_session_sync() for the synchronous,
             * blocking version of this method.
             * @param session_type A #MMOmaSessionType.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            start_client_initiated_session(
                session_type: OmaSessionType | null,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with
             * mm_modem_oma_start_client_initiated_session().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_oma_start_client_initiated_session().
             * @returns %TRUE if the session was started, %FALSE if @error is set.
             */
            start_client_initiated_session_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously starts a client-initiated OMA device management session.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_oma_start_client_initiated_session() for the asynchronous version
             * of this method.
             * @param session_type A #MMOmaSessionType.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the session was started, %FALSE if @error is set.
             */
            start_client_initiated_session_sync(
                session_type: OmaSessionType | null,
                cancellable?: Gio.Cancellable | null,
            ): boolean;

            // Inherited properties
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Oma.Features">"Features"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get features(): number;
            set features(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Oma.PendingNetworkInitiatedSessions">"PendingNetworkInitiatedSessions"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get pending_network_initiated_sessions(): GLib.Variant;
            set pending_network_initiated_sessions(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Oma.PendingNetworkInitiatedSessions">"PendingNetworkInitiatedSessions"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get pendingNetworkInitiatedSessions(): GLib.Variant;
            set pendingNetworkInitiatedSessions(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Oma.SessionState">"SessionState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get session_state(): number;
            set session_state(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Oma.SessionState">"SessionState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get sessionState(): number;
            set sessionState(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Oma.SessionType">"SessionType"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get session_type(): number;
            set session_type(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Oma.SessionType">"SessionType"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get sessionType(): number;
            set sessionType(val: number);

            // Inherited methods
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            init_async(io_priority: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             * @returns %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present.
             */
            init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Finishes the async construction for the various g_async_initable_new
             * calls, returning the created object or %NULL on error.
             * @param res the #GAsyncResult from the callback
             * @returns a newly created #GObject,      or %NULL on error. Free with g_object_unref().
             */
            new_finish(res: Gio.AsyncResult): ModemOma;
            // Conflicted with ModemManager.GdbusModemOmaProxy.new_finish
            new_finish(...args: never[]): any;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            vfunc_init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             */
            vfunc_init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.AcceptNetworkInitiatedSession">AcceptNetworkInitiatedSession()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_oma_call_accept_network_initiated_session_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_oma_call_accept_network_initiated_session_sync() for the synchronous, blocking version of this method.
             * @param arg_session_id Argument to pass with the method invocation.
             * @param arg_accept Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_accept_network_initiated_session(
                arg_session_id: number,
                arg_accept: boolean,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.AcceptNetworkInitiatedSession">AcceptNetworkInitiatedSession()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_oma_call_accept_network_initiated_session_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_oma_call_accept_network_initiated_session_sync() for the synchronous, blocking version of this method.
             * @param arg_session_id Argument to pass with the method invocation.
             * @param arg_accept Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_accept_network_initiated_session(
                arg_session_id: number,
                arg_accept: boolean,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.AcceptNetworkInitiatedSession">AcceptNetworkInitiatedSession()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_oma_call_accept_network_initiated_session_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_oma_call_accept_network_initiated_session_sync() for the synchronous, blocking version of this method.
             * @param arg_session_id Argument to pass with the method invocation.
             * @param arg_accept Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_accept_network_initiated_session(
                arg_session_id: number,
                arg_accept: boolean,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_oma_call_accept_network_initiated_session().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_oma_call_accept_network_initiated_session().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_accept_network_initiated_session_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.AcceptNetworkInitiatedSession">AcceptNetworkInitiatedSession()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_oma_call_accept_network_initiated_session() for the asynchronous version of this method.
             * @param arg_session_id Argument to pass with the method invocation.
             * @param arg_accept Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_accept_network_initiated_session_sync(
                arg_session_id: number,
                arg_accept: boolean,
                cancellable?: Gio.Cancellable | null,
            ): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.CancelSession">CancelSession()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_oma_call_cancel_session_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_oma_call_cancel_session_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_cancel_session(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.CancelSession">CancelSession()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_oma_call_cancel_session_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_oma_call_cancel_session_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_cancel_session(
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.CancelSession">CancelSession()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_oma_call_cancel_session_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_oma_call_cancel_session_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_cancel_session(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_oma_call_cancel_session().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_oma_call_cancel_session().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_cancel_session_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.CancelSession">CancelSession()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_oma_call_cancel_session() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_cancel_session_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.Setup">Setup()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_oma_call_setup_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_oma_call_setup_sync() for the synchronous, blocking version of this method.
             * @param arg_features Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_setup(arg_features: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.Setup">Setup()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_oma_call_setup_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_oma_call_setup_sync() for the synchronous, blocking version of this method.
             * @param arg_features Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_setup(
                arg_features: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.Setup">Setup()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_oma_call_setup_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_oma_call_setup_sync() for the synchronous, blocking version of this method.
             * @param arg_features Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_setup(
                arg_features: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_oma_call_setup().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_oma_call_setup().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_setup_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.Setup">Setup()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_oma_call_setup() for the asynchronous version of this method.
             * @param arg_features Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_setup_sync(arg_features: number, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.StartClientInitiatedSession">StartClientInitiatedSession()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_oma_call_start_client_initiated_session_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_oma_call_start_client_initiated_session_sync() for the synchronous, blocking version of this method.
             * @param arg_session_type Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_start_client_initiated_session(
                arg_session_type: number,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.StartClientInitiatedSession">StartClientInitiatedSession()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_oma_call_start_client_initiated_session_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_oma_call_start_client_initiated_session_sync() for the synchronous, blocking version of this method.
             * @param arg_session_type Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_start_client_initiated_session(
                arg_session_type: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.StartClientInitiatedSession">StartClientInitiatedSession()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_oma_call_start_client_initiated_session_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_oma_call_start_client_initiated_session_sync() for the synchronous, blocking version of this method.
             * @param arg_session_type Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_start_client_initiated_session(
                arg_session_type: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_oma_call_start_client_initiated_session().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_oma_call_start_client_initiated_session().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_start_client_initiated_session_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.StartClientInitiatedSession">StartClientInitiatedSession()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_oma_call_start_client_initiated_session() for the asynchronous version of this method.
             * @param arg_session_type Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_start_client_initiated_session_sync(
                arg_session_type: number,
                cancellable?: Gio.Cancellable | null,
            ): boolean;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.AcceptNetworkInitiatedSession">AcceptNetworkInitiatedSession()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_accept_network_initiated_session(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.CancelSession">CancelSession()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_cancel_session(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.Setup">Setup()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_setup(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.StartClientInitiatedSession">StartClientInitiatedSession()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_start_client_initiated_session(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Emits the <link linkend="gdbus-signal-org-freedesktop-ModemManager1-Modem-Oma.SessionStateChanged">"SessionStateChanged"</link> D-Bus signal.
             * @param arg_old_session_state Argument to pass with the signal.
             * @param arg_new_session_state Argument to pass with the signal.
             * @param arg_session_state_failed_reason Argument to pass with the signal.
             */
            emit_session_state_changed(
                arg_old_session_state: number,
                arg_new_session_state: number,
                arg_session_state_failed_reason: number,
            ): void;
            vfunc_handle_accept_network_initiated_session(
                invocation: Gio.DBusMethodInvocation,
                arg_session_id: number,
                arg_accept: boolean,
            ): boolean;
            vfunc_handle_cancel_session(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_setup(invocation: Gio.DBusMethodInvocation, arg_features: number): boolean;
            vfunc_handle_start_client_initiated_session(
                invocation: Gio.DBusMethodInvocation,
                arg_session_type: number,
            ): boolean;
            vfunc_session_state_changed(
                arg_old_session_state: number,
                arg_new_session_state: number,
                arg_session_state_failed_reason: number,
            ): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace ModemSar {
            // Constructor properties interface

            interface ConstructorProps
                extends GdbusModemSarProxy.ConstructorProps,
                    Gio.AsyncInitable.ConstructorProps,
                    Gio.DBusInterface.ConstructorProps,
                    Gio.Initable.ConstructorProps,
                    GdbusModemSar.ConstructorProps {}
        }

        /**
         * The #MMModemSar structure contains private data and should only be accessed
         * using the provided API.
         */
        class ModemSar
            extends GdbusModemSarProxy
            implements Gio.AsyncInitable<ModemSar>, Gio.DBusInterface, Gio.Initable, GdbusModemSar
        {
            static $gtype: GObject.GType<ModemSar>;

            // Constructors

            constructor(properties?: Partial<ModemSar.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Methods

            /**
             * Gets a copy of the DBus path of the #MMObject object which implements this
             * interface.
             * @returns The DBus path of the #MMObject. The returned value should be freed with g_free().
             */
            dup_path(): string;
            /**
             * Asynchronously enable or disable dynamic SAR.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_sar_enable_finish() to get the result of the operation.
             *
             * See mm_modem_sar_enable_sync() for the synchronous, blocking version of
             * this method.
             * @param enable %TRUE to enable dynamic SAR and %FALSE to disable it.
             * @param cancellable A #GCancellable or %NULL.
             */
            enable(enable: boolean, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously enable or disable dynamic SAR.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_sar_enable_finish() to get the result of the operation.
             *
             * See mm_modem_sar_enable_sync() for the synchronous, blocking version of
             * this method.
             * @param enable %TRUE to enable dynamic SAR and %FALSE to disable it.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            enable(
                enable: boolean,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously enable or disable dynamic SAR.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_sar_enable_finish() to get the result of the operation.
             *
             * See mm_modem_sar_enable_sync() for the synchronous, blocking version of
             * this method.
             * @param enable %TRUE to enable dynamic SAR and %FALSE to disable it.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            enable(
                enable: boolean,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_modem_sar_enable().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_sar_enable().
             * @returns %TRUE if the enable was successful, %FALSE if @error is set.
             */
            enable_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously enable or disable dynamic SAR.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_sar_enable() for the asynchronous version of this method.
             * @param enable %TRUE to enable dynamic SAR and %FALSE to disable it.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the enable was successful, %FALSE if @error is set.
             */
            enable_sync(enable: boolean, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Gets the DBus path of the #MMObject which implements this interface.
             * @returns The DBus path of the #MMObject object.
             */
            get_path(): string;
            /**
             * Gets the index of the SAR power level mapping table.
             * @returns the index.
             */
            get_power_level(): number;
            /**
             * Gets the state of dynamic SAR.
             * @returns %TRUE if dynamic SAR is enabled, %FALSE otherwise.
             */
            get_state(): boolean;
            /**
             * Asynchronously set current dynamic SAR power level.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_sar_set_power_level_finish() to get the result of the operation.
             *
             * See mm_modem_sar_set_power_level_sync() for the synchronous, blocking version of
             * this method.
             * @param level Index of the SAR power level mapping table
             * @param cancellable A #GCancellable or %NULL.
             */
            set_power_level(level: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously set current dynamic SAR power level.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_sar_set_power_level_finish() to get the result of the operation.
             *
             * See mm_modem_sar_set_power_level_sync() for the synchronous, blocking version of
             * this method.
             * @param level Index of the SAR power level mapping table
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            set_power_level(
                level: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously set current dynamic SAR power level.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_sar_set_power_level_finish() to get the result of the operation.
             *
             * See mm_modem_sar_set_power_level_sync() for the synchronous, blocking version of
             * this method.
             * @param level Index of the SAR power level mapping table
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            set_power_level(
                level: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            set_power_level_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously set current dynamic SAR power level.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_sar_set_power_level() for the asynchronous version of this method.
             * @param level Index of the SAR power level mapping table
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if set power level was successful, %FALSE if @error is set.
             */
            set_power_level_sync(level: number, cancellable?: Gio.Cancellable | null): boolean;

            // Inherited properties
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Sar.PowerLevel">"PowerLevel"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get power_level(): number;
            set power_level(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Sar.PowerLevel">"PowerLevel"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get powerLevel(): number;
            set powerLevel(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Sar.State">"State"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get state(): boolean;
            set state(val: boolean);

            // Inherited methods
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            init_async(io_priority: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             * @returns %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present.
             */
            init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Finishes the async construction for the various g_async_initable_new
             * calls, returning the created object or %NULL on error.
             * @param res the #GAsyncResult from the callback
             * @returns a newly created #GObject,      or %NULL on error. Free with g_object_unref().
             */
            new_finish(res: Gio.AsyncResult): ModemSar;
            // Conflicted with ModemManager.GdbusModemSarProxy.new_finish
            new_finish(...args: never[]): any;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            vfunc_init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             */
            vfunc_init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Sar.Enable">Enable()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_sar_call_enable_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_sar_call_enable_sync() for the synchronous, blocking version of this method.
             * @param arg_enable Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_enable(arg_enable: boolean, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Sar.Enable">Enable()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_sar_call_enable_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_sar_call_enable_sync() for the synchronous, blocking version of this method.
             * @param arg_enable Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_enable(
                arg_enable: boolean,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Sar.Enable">Enable()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_sar_call_enable_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_sar_call_enable_sync() for the synchronous, blocking version of this method.
             * @param arg_enable Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_enable(
                arg_enable: boolean,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_sar_call_enable().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_sar_call_enable().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_enable_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Sar.Enable">Enable()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_sar_call_enable() for the asynchronous version of this method.
             * @param arg_enable Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_enable_sync(arg_enable: boolean, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Sar.SetPowerLevel">SetPowerLevel()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_sar_call_set_power_level_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_sar_call_set_power_level_sync() for the synchronous, blocking version of this method.
             * @param arg_level Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set_power_level(arg_level: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Sar.SetPowerLevel">SetPowerLevel()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_sar_call_set_power_level_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_sar_call_set_power_level_sync() for the synchronous, blocking version of this method.
             * @param arg_level Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_power_level(
                arg_level: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Sar.SetPowerLevel">SetPowerLevel()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_sar_call_set_power_level_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_sar_call_set_power_level_sync() for the synchronous, blocking version of this method.
             * @param arg_level Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_power_level(
                arg_level: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_sar_call_set_power_level().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_sar_call_set_power_level().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_power_level_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Sar.SetPowerLevel">SetPowerLevel()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_sar_call_set_power_level() for the asynchronous version of this method.
             * @param arg_level Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_power_level_sync(arg_level: number, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Sar.Enable">Enable()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_enable(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Sar.SetPowerLevel">SetPowerLevel()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_set_power_level(invocation: Gio.DBusMethodInvocation): void;
            vfunc_handle_enable(invocation: Gio.DBusMethodInvocation, arg_enable: boolean): boolean;
            vfunc_handle_set_power_level(invocation: Gio.DBusMethodInvocation, arg_level: number): boolean;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace ModemSignal {
            // Constructor properties interface

            interface ConstructorProps
                extends GdbusModemSignalProxy.ConstructorProps,
                    Gio.AsyncInitable.ConstructorProps,
                    Gio.DBusInterface.ConstructorProps,
                    Gio.Initable.ConstructorProps,
                    GdbusModemSignal.ConstructorProps {}
        }

        /**
         * The #MMModemSignal structure contains private data and should only be accessed
         * using the provided API.
         */
        class ModemSignal
            extends GdbusModemSignalProxy
            implements Gio.AsyncInitable<ModemSignal>, Gio.DBusInterface, Gio.Initable, GdbusModemSignal
        {
            static $gtype: GObject.GType<ModemSignal>;

            // Constructors

            constructor(properties?: Partial<ModemSignal.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Methods

            /**
             * Gets a copy of the DBus path of the #MMObject object which implements this
             * interface.
             * @returns The DBus path of the #MMObject. The returned value should be freed with g_free().
             */
            dup_path(): string;
            /**
             * Gets a #MMSignal object specifying the CDMA signal information.
             *
             * <warning>The values reported by `self` are not updated when the values in the
             * interface change. Instead, the client is expected to call
             * mm_modem_signal_get_cdma() again to get a new #MMSignal with the new values.
             * </warning>
             * @returns A #MMSignal that must be freed with g_object_unref() or %NULL if unknown.
             */
            get_cdma(): Signal;
            /**
             * Gets whether the error rate threshold is enabled or not.
             * @returns %TRUE if the error rate threshold is enabled, %FALSE otherwise.
             */
            get_error_rate_threshold(): boolean;
            /**
             * Gets a #MMSignal object specifying the EV-DO signal information.
             *
             * <warning>The values reported by `self` are not updated when the values in the
             * interface change. Instead, the client is expected to call
             * mm_modem_signal_get_evdo() again to get a new #MMSignal with the new values.
             * </warning>
             * @returns A #MMSignal that must be freed with g_object_unref() or %NULL if unknown.
             */
            get_evdo(): Signal;
            /**
             * Gets a #MMSignal object specifying the GSM signal information.
             *
             * <warning>The values reported by `self` are not updated when the values in the
             * interface change. Instead, the client is expected to call
             * mm_modem_signal_get_gsm() again to get a new #MMSignal with the
             * new values.</warning>
             * @returns A #MMSignal that must be freed with g_object_unref() or %NULL if unknown.
             */
            get_gsm(): Signal;
            /**
             * Gets a #MMSignal object specifying the LTE signal information.
             *
             * <warning>The values reported by `self` are not updated when the values in the
             * interface change. Instead, the client is expected to call
             * mm_modem_signal_get_lte() again to get a new #MMSignal with the new values.
             * </warning>
             * @returns A #MMSignal that must be freed with g_object_unref() or %NULL if unknown.
             */
            get_lte(): Signal;
            /**
             * Gets a #MMSignal object specifying the 5G signal information.
             *
             * <warning>The values reported by `self` are not updated when the values in the
             * interface change. Instead, the client is expected to call
             * mm_modem_signal_get_nr5g() again to get a new #MMSignal with the new values.
             * </warning>
             * @returns A #MMSignal that must be freed with g_object_unref() or %NULL if unknown.
             */
            get_nr5g(): Signal;
            /**
             * Gets the DBus path of the #MMObject which implements this interface.
             * @returns The DBus path of the #MMObject object.
             */
            get_path(): string;
            /**
             * Gets the currently configured refresh rate.
             * @returns the refresh rate, in seconds.
             */
            get_rate(): number;
            /**
             * Gets the currently configured RSSI threshold, in dBm.
             *
             * A value of 0 indicates the threshold is disabled.
             * @returns the RSSI threshold.
             */
            get_rssi_threshold(): number;
            /**
             * Gets a #MMSignal object specifying the UMTS signal information.
             *
             * <warning>The values reported by `self` are not updated when the values in the
             * interface change. Instead, the client is expected to call
             * mm_modem_signal_get_umts() again to get a new #MMSignal with the new values.
             * </warning>
             * @returns A #MMSignal that must be freed with g_object_unref() or %NULL if unknown.
             */
            get_umts(): Signal;
            /**
             * Gets a #MMSignal object specifying the CDMA signal information.
             *
             * <warning>The returned value is only valid until the property changes so it is
             * only safe to use this function on the thread where `self` was constructed. Use
             * mm_modem_signal_get_cdma() if on another thread.</warning>
             * @returns A #MMSignal. Do not free the returned value, it belongs to @self.
             */
            peek_cdma(): Signal;
            /**
             * Gets a #MMSignal object specifying the EV-DO signal information.
             *
             * <warning>The returned value is only valid until the property changes so it is
             * only safe to use this function on the thread where `self` was constructed. Use
             * mm_modem_signal_get_evdo() if on another thread.</warning>
             * @returns A #MMSignal. Do not free the returned value, it belongs to @self.
             */
            peek_evdo(): Signal;
            /**
             * Gets a #MMSignal object specifying the GSM signal information.
             *
             * <warning>The returned value is only valid until the property changes so it is
             * only safe to use this function on the thread where `self` was constructed. Use
             * mm_modem_signal_get_gsm() if on another thread.</warning>
             * @returns A #MMSignal. Do not free the returned value, it belongs to @self.
             */
            peek_gsm(): Signal;
            /**
             * Gets a #MMSignal object specifying the LTE signal information.
             *
             * <warning>The returned value is only valid until the property changes so it is
             * only safe to use this function on the thread where `self` was constructed. Use
             * mm_modem_signal_get_lte() if on another thread.</warning>
             * @returns A #MMSignal. Do not free the returned value, it belongs to @self.
             */
            peek_lte(): Signal;
            /**
             * Gets a #MMSignal object specifying the 5G signal information.
             *
             * <warning>The returned value is only valid until the property changes so it is
             * only safe to use this function on the thread where `self` was constructed. Use
             * mm_modem_signal_get_nr5g() if on another thread.</warning>
             * @returns A #MMSignal. Do not free the returned value, it belongs to @self.
             */
            peek_nr5g(): Signal;
            /**
             * Gets a #MMSignal object specifying the UMTS signal information.
             *
             * <warning>The returned value is only valid until the property changes so it is
             * only safe to use this function on the thread where `self` was constructed. Use
             * mm_modem_signal_get_umts() if on another thread.</warning>
             * @returns A #MMSignal. Do not free the returned value, it belongs to @self.
             */
            peek_umts(): Signal;
            /**
             * Asynchronously enables or disables the extended signal quality information
             * retrieval via periodic polling.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_signal_setup_finish() to get the result of the operation.
             *
             * See mm_modem_signal_setup_sync() for the synchronous, blocking version of
             * this method.
             * @param rate Refresh rate to set, in seconds. Use 0 to disable periodic polling.
             * @param cancellable A #GCancellable or %NULL.
             */
            setup(rate: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously enables or disables the extended signal quality information
             * retrieval via periodic polling.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_signal_setup_finish() to get the result of the operation.
             *
             * See mm_modem_signal_setup_sync() for the synchronous, blocking version of
             * this method.
             * @param rate Refresh rate to set, in seconds. Use 0 to disable periodic polling.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            setup(
                rate: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously enables or disables the extended signal quality information
             * retrieval via periodic polling.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_signal_setup_finish() to get the result of the operation.
             *
             * See mm_modem_signal_setup_sync() for the synchronous, blocking version of
             * this method.
             * @param rate Refresh rate to set, in seconds. Use 0 to disable periodic polling.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            setup(
                rate: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_modem_signal_setup().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_signal_setup().
             * @returns %TRUE if the setup was successful, %FALSE if @error is set.
             */
            setup_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously enables or disables the extended signal quality information
             * retrieval via periodic polling.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_signal_setup() for the asynchronous version of this method.
             * @param rate Refresh rate to set, in seconds. Use 0 to disable periodic polling.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the setup was successful, %FALSE if @error is set.
             */
            setup_sync(rate: number, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously setups thresholds so that the device itself decides when to report the
             * extended signal quality information updates.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_signal_setup_thresholds_finish() to get the result of the operation.
             *
             * See mm_modem_signal_setup_thresholds_sync() for the synchronous, blocking version of
             * this method.
             * @param properties Threshold values to set.
             * @param cancellable A #GCancellable or %NULL.
             */
            setup_thresholds(
                properties: SignalThresholdProperties,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronously setups thresholds so that the device itself decides when to report the
             * extended signal quality information updates.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_signal_setup_thresholds_finish() to get the result of the operation.
             *
             * See mm_modem_signal_setup_thresholds_sync() for the synchronous, blocking version of
             * this method.
             * @param properties Threshold values to set.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            setup_thresholds(
                properties: SignalThresholdProperties,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously setups thresholds so that the device itself decides when to report the
             * extended signal quality information updates.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_signal_setup_thresholds_finish() to get the result of the operation.
             *
             * See mm_modem_signal_setup_thresholds_sync() for the synchronous, blocking version of
             * this method.
             * @param properties Threshold values to set.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            setup_thresholds(
                properties: SignalThresholdProperties,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_modem_signal_setup_thresholds().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_signal_setup_thresholds().
             * @returns %TRUE if the setup was successful, %FALSE if @error is set.
             */
            setup_thresholds_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously setups thresholds so that the device itself decides when to report the
             * extended signal quality information updates.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_signal_setup_thresholds() for the asynchronous version of this method.
             * @param properties Threshold values to set.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the setup was successful, %FALSE if @error is set.
             */
            setup_thresholds_sync(properties: SignalThresholdProperties, cancellable?: Gio.Cancellable | null): boolean;

            // Inherited properties
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Signal.Cdma">"Cdma"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get cdma(): GLib.Variant;
            set cdma(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Signal.ErrorRateThreshold">"ErrorRateThreshold"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get error_rate_threshold(): boolean;
            set error_rate_threshold(val: boolean);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Signal.ErrorRateThreshold">"ErrorRateThreshold"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get errorRateThreshold(): boolean;
            set errorRateThreshold(val: boolean);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Signal.Evdo">"Evdo"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get evdo(): GLib.Variant;
            set evdo(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Signal.Gsm">"Gsm"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get gsm(): GLib.Variant;
            set gsm(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Signal.Lte">"Lte"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get lte(): GLib.Variant;
            set lte(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Signal.Nr5g">"Nr5g"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get nr5g(): GLib.Variant;
            set nr5g(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Signal.Rate">"Rate"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get rate(): number;
            set rate(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Signal.RssiThreshold">"RssiThreshold"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get rssi_threshold(): number;
            set rssi_threshold(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Signal.RssiThreshold">"RssiThreshold"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get rssiThreshold(): number;
            set rssiThreshold(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Signal.Umts">"Umts"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get umts(): GLib.Variant;
            set umts(val: GLib.Variant);

            // Inherited methods
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            init_async(io_priority: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             * @returns %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present.
             */
            init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Finishes the async construction for the various g_async_initable_new
             * calls, returning the created object or %NULL on error.
             * @param res the #GAsyncResult from the callback
             * @returns a newly created #GObject,      or %NULL on error. Free with g_object_unref().
             */
            new_finish(res: Gio.AsyncResult): ModemSignal;
            // Conflicted with ModemManager.GdbusModemSignalProxy.new_finish
            new_finish(...args: never[]): any;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            vfunc_init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             */
            vfunc_init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Signal.Setup">Setup()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_signal_call_setup_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_signal_call_setup_sync() for the synchronous, blocking version of this method.
             * @param arg_rate Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_setup(arg_rate: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Signal.Setup">Setup()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_signal_call_setup_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_signal_call_setup_sync() for the synchronous, blocking version of this method.
             * @param arg_rate Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_setup(
                arg_rate: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Signal.Setup">Setup()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_signal_call_setup_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_signal_call_setup_sync() for the synchronous, blocking version of this method.
             * @param arg_rate Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_setup(
                arg_rate: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_signal_call_setup().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_signal_call_setup().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_setup_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Signal.Setup">Setup()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_signal_call_setup() for the asynchronous version of this method.
             * @param arg_rate Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_setup_sync(arg_rate: number, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Signal.SetupThresholds">SetupThresholds()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_signal_call_setup_thresholds_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_signal_call_setup_thresholds_sync() for the synchronous, blocking version of this method.
             * @param arg_settings Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_setup_thresholds(arg_settings: GLib.Variant, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Signal.SetupThresholds">SetupThresholds()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_signal_call_setup_thresholds_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_signal_call_setup_thresholds_sync() for the synchronous, blocking version of this method.
             * @param arg_settings Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_setup_thresholds(
                arg_settings: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Signal.SetupThresholds">SetupThresholds()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_signal_call_setup_thresholds_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_signal_call_setup_thresholds_sync() for the synchronous, blocking version of this method.
             * @param arg_settings Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_setup_thresholds(
                arg_settings: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_signal_call_setup_thresholds().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_signal_call_setup_thresholds().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_setup_thresholds_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Signal.SetupThresholds">SetupThresholds()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_signal_call_setup_thresholds() for the asynchronous version of this method.
             * @param arg_settings Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_setup_thresholds_sync(arg_settings: GLib.Variant, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Signal.Setup">Setup()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_setup(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Signal.SetupThresholds">SetupThresholds()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_setup_thresholds(invocation: Gio.DBusMethodInvocation): void;
            vfunc_handle_setup(invocation: Gio.DBusMethodInvocation, arg_rate: number): boolean;
            vfunc_handle_setup_thresholds(invocation: Gio.DBusMethodInvocation, arg_settings: GLib.Variant): boolean;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace ModemSimple {
            // Constructor properties interface

            interface ConstructorProps
                extends GdbusModemSimpleProxy.ConstructorProps,
                    Gio.AsyncInitable.ConstructorProps,
                    Gio.DBusInterface.ConstructorProps,
                    Gio.Initable.ConstructorProps,
                    GdbusModemSimple.ConstructorProps {}
        }

        /**
         * The #MMModemSimple structure contains private data and should only be accessed
         * using the provided API.
         */
        class ModemSimple
            extends GdbusModemSimpleProxy
            implements Gio.AsyncInitable<ModemSimple>, Gio.DBusInterface, Gio.Initable, GdbusModemSimple
        {
            static $gtype: GObject.GType<ModemSimple>;

            // Constructors

            constructor(properties?: Partial<ModemSimple.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Methods

            /**
             * Asynchronously requests to connect the modem using the given `properties`.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_simple_connect_finish() to get the result of the operation.
             *
             * See mm_modem_simple_connect_sync() for the synchronous, blocking version of
             * this method.
             * @param properties A #MMSimpleConnectProperties bundle.
             * @param cancellable A #GCancellable or %NULL.
             */
            connect(properties: SimpleConnectProperties, cancellable?: Gio.Cancellable | null): Promise<Bearer>;
            /**
             * Asynchronously requests to connect the modem using the given `properties`.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_simple_connect_finish() to get the result of the operation.
             *
             * See mm_modem_simple_connect_sync() for the synchronous, blocking version of
             * this method.
             * @param properties A #MMSimpleConnectProperties bundle.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            connect(
                properties: SimpleConnectProperties,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously requests to connect the modem using the given `properties`.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_simple_connect_finish() to get the result of the operation.
             *
             * See mm_modem_simple_connect_sync() for the synchronous, blocking version of
             * this method.
             * @param properties A #MMSimpleConnectProperties bundle.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            connect(
                properties: SimpleConnectProperties,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<Bearer> | void;
            connect(...args: never[]): any;
            /**
             * Finishes an operation started with mm_modem_simple_connect().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_simple_connect().
             * @returns A #MMBearer, or %FALSE if @error is set. The returned value must be freed with g_object_unref().
             */
            connect_finish(res: Gio.AsyncResult): Bearer;
            /**
             * Synchronously requests to connect the modem using the given `properties`.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_simple_connect() for the asynchronous version of this method.
             * @param properties A #MMSimpleConnectProperties bundle.
             * @param cancellable A #GCancellable or %NULL.
             * @returns A #MMBearer, or %FALSE if @error is set. The returned value must be freed with g_object_unref().
             */
            connect_sync(properties: SimpleConnectProperties, cancellable?: Gio.Cancellable | null): Bearer;
            /**
             * Asynchronously requests to disconnect the modem.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_simple_disconnect_finish() to get the result of the operation.
             *
             * See mm_modem_simple_disconnect_sync() for the synchronous, blocking version
             * of this method.
             * @param bearer Path of the bearer to disconnect, or %NULL to  disconnect all connected bearers.
             * @param cancellable A #GCancellable or %NULL.
             */
            disconnect(bearer?: string | null, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously requests to disconnect the modem.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_simple_disconnect_finish() to get the result of the operation.
             *
             * See mm_modem_simple_disconnect_sync() for the synchronous, blocking version
             * of this method.
             * @param bearer Path of the bearer to disconnect, or %NULL to  disconnect all connected bearers.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            disconnect(
                bearer: string | null,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously requests to disconnect the modem.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_simple_disconnect_finish() to get the result of the operation.
             *
             * See mm_modem_simple_disconnect_sync() for the synchronous, blocking version
             * of this method.
             * @param bearer Path of the bearer to disconnect, or %NULL to  disconnect all connected bearers.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            disconnect(
                bearer?: string | null,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            // Conflicted with GObject.Object.disconnect
            disconnect(...args: never[]): any;
            /**
             * Finishes an operation started with mm_modem_simple_disconnect().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_simple_disconnect().
             * @returns %TRUE if the modem is successfully disconnected, %FALSE if @error is set.
             */
            disconnect_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously requests to disconnect the modem.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_simple_disconnect() for the asynchronous version of this method.
             * @param bearer Path of the bearer to disconnect, or %NULL to  disconnect all connected bearers.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the modem is successfully disconnected, %FALSE if @error is set.
             */
            disconnect_sync(bearer?: string | null, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Gets a copy of the DBus path of the #MMObject object which implements this
             * interface.
             * @returns The DBus path of the #MMObject. The returned value should be freed with g_free().
             */
            dup_path(): string;
            /**
             * Gets the DBus path of the #MMObject which implements this interface.
             * @returns The DBus path of the #MMObject object.
             */
            get_path(): string;
            /**
             * Asynchronously requests a compilation of the status of the modem.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_simple_get_status_finish() to get the result of the operation.
             *
             * See mm_modem_simple_get_status_sync() for the synchronous, blocking version
             * of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            get_status(cancellable?: Gio.Cancellable | null): Promise<SimpleStatus>;
            /**
             * Asynchronously requests a compilation of the status of the modem.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_simple_get_status_finish() to get the result of the operation.
             *
             * See mm_modem_simple_get_status_sync() for the synchronous, blocking version
             * of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            get_status(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously requests a compilation of the status of the modem.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_simple_get_status_finish() to get the result of the operation.
             *
             * See mm_modem_simple_get_status_sync() for the synchronous, blocking version
             * of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            get_status(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<SimpleStatus> | void;
            /**
             * Finishes an operation started with mm_modem_simple_get_status().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_simple_connect().
             * @returns A #MMSimpleStatus, or %FALSE if @error is set. The returned value must be freed with g_object_unref().
             */
            get_status_finish(res: Gio.AsyncResult): SimpleStatus;
            /**
             * Synchronously requests a compilation of the status of the modem.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_simple_get_status() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns A #MMSimpleStatus, or %FALSE if @error is set. The returned value must be freed with g_object_unref().
             */
            get_status_sync(cancellable?: Gio.Cancellable | null): SimpleStatus;

            // Inherited methods
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            init_async(io_priority: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             * @returns %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present.
             */
            init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Finishes the async construction for the various g_async_initable_new
             * calls, returning the created object or %NULL on error.
             * @param res the #GAsyncResult from the callback
             * @returns a newly created #GObject,      or %NULL on error. Free with g_object_unref().
             */
            new_finish(res: Gio.AsyncResult): ModemSimple;
            // Conflicted with ModemManager.GdbusModemSimpleProxy.new_finish
            new_finish(...args: never[]): any;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            vfunc_init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             */
            vfunc_init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Simple.Connect">Connect()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_simple_call_connect_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_simple_call_connect_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_connect(arg_properties: GLib.Variant, cancellable?: Gio.Cancellable | null): Promise<string>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Simple.Connect">Connect()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_simple_call_connect_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_simple_call_connect_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_connect(
                arg_properties: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Simple.Connect">Connect()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_simple_call_connect_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_simple_call_connect_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_connect(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<string> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_simple_call_connect().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_simple_call_connect().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_connect_finish(res: Gio.AsyncResult): [boolean, string];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Simple.Connect">Connect()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_simple_call_connect() for the asynchronous version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_connect_sync(arg_properties: GLib.Variant, cancellable?: Gio.Cancellable | null): [boolean, string];
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Simple.Disconnect">Disconnect()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_simple_call_disconnect_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_simple_call_disconnect_sync() for the synchronous, blocking version of this method.
             * @param arg_bearer Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_disconnect(arg_bearer: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Simple.Disconnect">Disconnect()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_simple_call_disconnect_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_simple_call_disconnect_sync() for the synchronous, blocking version of this method.
             * @param arg_bearer Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_disconnect(
                arg_bearer: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Simple.Disconnect">Disconnect()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_simple_call_disconnect_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_simple_call_disconnect_sync() for the synchronous, blocking version of this method.
             * @param arg_bearer Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_disconnect(
                arg_bearer: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_simple_call_disconnect().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_simple_call_disconnect().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_disconnect_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Simple.Disconnect">Disconnect()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_simple_call_disconnect() for the asynchronous version of this method.
             * @param arg_bearer Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_disconnect_sync(arg_bearer: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Simple.GetStatus">GetStatus()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_simple_call_get_status_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_simple_call_get_status_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_get_status(cancellable?: Gio.Cancellable | null): Promise<GLib.Variant | null>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Simple.GetStatus">GetStatus()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_simple_call_get_status_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_simple_call_get_status_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_get_status(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Simple.GetStatus">GetStatus()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_simple_call_get_status_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_simple_call_get_status_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_get_status(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<GLib.Variant | null> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_simple_call_get_status().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_simple_call_get_status().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_get_status_finish(res: Gio.AsyncResult): [boolean, GLib.Variant | null];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Simple.GetStatus">GetStatus()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_simple_call_get_status() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_get_status_sync(cancellable?: Gio.Cancellable | null): [boolean, GLib.Variant | null];
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Simple.Connect">Connect()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param bearer Parameter to return.
             */
            complete_connect(invocation: Gio.DBusMethodInvocation, bearer: string): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Simple.Disconnect">Disconnect()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_disconnect(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Simple.GetStatus">GetStatus()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param properties Parameter to return.
             */
            complete_get_status(invocation: Gio.DBusMethodInvocation, properties: GLib.Variant): void;
            vfunc_handle_connect(invocation: Gio.DBusMethodInvocation, arg_properties: GLib.Variant): boolean;
            vfunc_handle_disconnect(invocation: Gio.DBusMethodInvocation, arg_bearer: string): boolean;
            vfunc_handle_get_status(invocation: Gio.DBusMethodInvocation): boolean;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace ModemTime {
            // Constructor properties interface

            interface ConstructorProps
                extends GdbusModemTimeProxy.ConstructorProps,
                    Gio.AsyncInitable.ConstructorProps,
                    Gio.DBusInterface.ConstructorProps,
                    Gio.Initable.ConstructorProps,
                    GdbusModemTime.ConstructorProps {}
        }

        /**
         * The #MMModemTime structure contains private data and should only be accessed
         * using the provided API.
         */
        class ModemTime
            extends GdbusModemTimeProxy
            implements Gio.AsyncInitable<ModemTime>, Gio.DBusInterface, Gio.Initable, GdbusModemTime
        {
            static $gtype: GObject.GType<ModemTime>;

            // Constructors

            constructor(properties?: Partial<ModemTime.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Methods

            /**
             * Gets a copy of the DBus path of the #MMObject object which implements this
             * interface.
             * @returns The DBus path of the #MMObject. The returned value should be freed with g_free().
             */
            dup_path(): string;
            /**
             * Asynchronously requests the current network time.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_time_get_network_time_finish() to get the result of the operation.
             *
             * See mm_modem_time_get_network_time_sync() for the synchronous, blocking
             * version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            get_network_time(cancellable?: Gio.Cancellable | null): Promise<string>;
            /**
             * Asynchronously requests the current network time.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_time_get_network_time_finish() to get the result of the operation.
             *
             * See mm_modem_time_get_network_time_sync() for the synchronous, blocking
             * version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            get_network_time(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously requests the current network time.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_time_get_network_time_finish() to get the result of the operation.
             *
             * See mm_modem_time_get_network_time_sync() for the synchronous, blocking
             * version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            get_network_time(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<string> | void;
            /**
             * Finishes an operation started with mm_modem_time_get_network_time().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_enable().
             * @returns A string containing the network time, or %NULL if @error is set. The returned value should be freed with g_free().
             */
            get_network_time_finish(res: Gio.AsyncResult): string;
            /**
             * Synchronously requests the current network time.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_time_get_network_time() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns A string containing the network time, or %NULL if @error is set. The returned value should be freed with g_free().
             */
            get_network_time_sync(cancellable?: Gio.Cancellable | null): string;
            /**
             * Gets the network timezone information.
             *
             * <warning>The values reported by `self` are not updated when the values in the
             * interface change. Instead, the client is expected to call
             * mm_modem_time_get_network_timezone() again to get a new #MMNetworkTimezone
             * with the new values.</warning>
             * @returns A #MMNetworkTimezone that must be freed with g_object_unref() or %NULL if unknown.
             */
            get_network_timezone(): NetworkTimezone;
            /**
             * Gets the DBus path of the #MMObject which implements this interface.
             * @returns The DBus path of the #MMObject object.
             */
            get_path(): string;
            /**
             * Gets the network timezone information.
             *
             * <warning>The returned value is only valid until the property changes so it is
             * only safe to use this function on the thread where `self` was constructed. Use
             * mm_modem_time_get_network_timezone() if on another thread.</warning>
             * @returns A #MMNetworkTimezone. Do not free the returned value, it belongs to @self.
             */
            peek_network_timezone(): NetworkTimezone;

            // Inherited properties
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Time.NetworkTimezone">"NetworkTimezone"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get network_timezone(): GLib.Variant;
            set network_timezone(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Time.NetworkTimezone">"NetworkTimezone"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get networkTimezone(): GLib.Variant;
            set networkTimezone(val: GLib.Variant);

            // Inherited methods
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            init_async(io_priority: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             * @returns %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present.
             */
            init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Finishes the async construction for the various g_async_initable_new
             * calls, returning the created object or %NULL on error.
             * @param res the #GAsyncResult from the callback
             * @returns a newly created #GObject,      or %NULL on error. Free with g_object_unref().
             */
            new_finish(res: Gio.AsyncResult): ModemTime;
            // Conflicted with ModemManager.GdbusModemTimeProxy.new_finish
            new_finish(...args: never[]): any;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            vfunc_init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             */
            vfunc_init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Time.GetNetworkTime">GetNetworkTime()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_time_call_get_network_time_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_time_call_get_network_time_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_get_network_time(cancellable?: Gio.Cancellable | null): Promise<string>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Time.GetNetworkTime">GetNetworkTime()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_time_call_get_network_time_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_time_call_get_network_time_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_get_network_time(
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Time.GetNetworkTime">GetNetworkTime()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_time_call_get_network_time_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_time_call_get_network_time_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_get_network_time(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<string> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_time_call_get_network_time().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_time_call_get_network_time().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_get_network_time_finish(res: Gio.AsyncResult): [boolean, string];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Time.GetNetworkTime">GetNetworkTime()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_time_call_get_network_time() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_get_network_time_sync(cancellable?: Gio.Cancellable | null): [boolean, string];
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Time.GetNetworkTime">GetNetworkTime()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param time Parameter to return.
             */
            complete_get_network_time(invocation: Gio.DBusMethodInvocation, time: string): void;
            /**
             * Emits the <link linkend="gdbus-signal-org-freedesktop-ModemManager1-Modem-Time.NetworkTimeChanged">"NetworkTimeChanged"</link> D-Bus signal.
             * @param arg_time Argument to pass with the signal.
             */
            emit_network_time_changed(arg_time: string): void;
            vfunc_handle_get_network_time(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_network_time_changed(arg_time: string): void;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace ModemVoice {
            // Constructor properties interface

            interface ConstructorProps
                extends GdbusModemVoiceProxy.ConstructorProps,
                    Gio.AsyncInitable.ConstructorProps,
                    Gio.DBusInterface.ConstructorProps,
                    Gio.Initable.ConstructorProps,
                    GdbusModemVoice.ConstructorProps {}
        }

        /**
         * The #MMModemVoice structure contains private data and should only be accessed
         * using the provided API.
         */
        class ModemVoice
            extends GdbusModemVoiceProxy
            implements Gio.AsyncInitable<ModemVoice>, Gio.DBusInterface, Gio.Initable, GdbusModemVoice
        {
            static $gtype: GObject.GType<ModemVoice>;

            // Constructors

            constructor(properties?: Partial<ModemVoice.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Methods

            /**
             * Asynchronously queries the status of the call waiting network service.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_voice_call_waiting_query_finish() to get the result of the
             * operation.
             *
             * See mm_modem_voice_call_waiting_query_sync() for the synchronous, blocking
             * version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_waiting_query(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously queries the status of the call waiting network service.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_voice_call_waiting_query_finish() to get the result of the
             * operation.
             *
             * See mm_modem_voice_call_waiting_query_sync() for the synchronous, blocking
             * version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            call_waiting_query(
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously queries the status of the call waiting network service.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_voice_call_waiting_query_finish() to get the result of the
             * operation.
             *
             * See mm_modem_voice_call_waiting_query_sync() for the synchronous, blocking
             * version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            call_waiting_query(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_modem_voice_call_waiting_query().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_voice_call_waiting_query().
             * @param status Output location where to store the status.
             * @returns %TRUE if @status is set, %FALSE if @error is set.
             */
            call_waiting_query_finish(res: Gio.AsyncResult, status: boolean): boolean;
            /**
             * Synchronously queries the status of the call waiting network service.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_voice_call_waiting_query() for the asynchronous version of this
             * method.
             * @param cancellable A #GCancellable or %NULL.
             * @param status Output location where to store the status.
             * @returns %TRUE if @status is set, %FALSE if @error is set.
             */
            call_waiting_query_sync(cancellable: Gio.Cancellable | null, status: boolean): boolean;
            /**
             * Asynchronously enables or disables the call waiting network service.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_voice_call_waiting_setup_finish() to get the result of the
             * operation.
             *
             * See mm_modem_voice_call_waiting_setup_sync() for the synchronous, blocking
             * version of this method.
             * @param enable Whether the call waiting service should be enabled.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_waiting_setup(enable: boolean, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously enables or disables the call waiting network service.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_voice_call_waiting_setup_finish() to get the result of the
             * operation.
             *
             * See mm_modem_voice_call_waiting_setup_sync() for the synchronous, blocking
             * version of this method.
             * @param enable Whether the call waiting service should be enabled.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            call_waiting_setup(
                enable: boolean,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously enables or disables the call waiting network service.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_voice_call_waiting_setup_finish() to get the result of the
             * operation.
             *
             * See mm_modem_voice_call_waiting_setup_sync() for the synchronous, blocking
             * version of this method.
             * @param enable Whether the call waiting service should be enabled.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            call_waiting_setup(
                enable: boolean,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_modem_voice_call_waiting_setup().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_voice_call_waiting_setup().
             * @returns %TRUE if  @status is set, %FALSE if @error is set.
             */
            call_waiting_setup_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously enables or disables the call waiting network service.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_voice_call_waiting_setup() for the asynchronous version of this
             * method.
             * @param enable Whether the call waiting service should be enabled.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the operation is successful, %FALSE if @error is set.
             */
            call_waiting_setup_sync(enable: boolean, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously creates a new #MMCall in the modem.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_voice_create_call_finish() to get the result of the operation.
             *
             * See mm_modem_voice_create_call_sync() for the synchronous, blocking version
             * of this method.
             * @param properties A ##MMCallProperties object with the properties to use.
             * @param cancellable A #GCancellable or %NULL.
             */
            create_call(properties: CallProperties, cancellable?: Gio.Cancellable | null): Promise<Call>;
            /**
             * Asynchronously creates a new #MMCall in the modem.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_voice_create_call_finish() to get the result of the operation.
             *
             * See mm_modem_voice_create_call_sync() for the synchronous, blocking version
             * of this method.
             * @param properties A ##MMCallProperties object with the properties to use.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            create_call(
                properties: CallProperties,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously creates a new #MMCall in the modem.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_voice_create_call_finish() to get the result of the operation.
             *
             * See mm_modem_voice_create_call_sync() for the synchronous, blocking version
             * of this method.
             * @param properties A ##MMCallProperties object with the properties to use.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            create_call(
                properties: CallProperties,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<Call> | void;
            /**
             * Finishes an operation started with mm_modem_voice_create_call().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_voice_create_call().
             * @returns A newly created #MMCall, or %NULL if @error is set. The returned value should be freed with g_object_unref().
             */
            create_call_finish(res: Gio.AsyncResult): Call;
            /**
             * Synchronously creates a new #MMCall in the modem.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_voice_create_call() for the asynchronous version of this method.
             * @param properties A ##MMCallProperties object with the properties to use.
             * @param cancellable A #GCancellable or %NULL.
             * @returns A newly created #MMCall, or %NULL if @error is set. The returned value should be freed with g_object_unref().
             */
            create_call_sync(properties: CallProperties, cancellable?: Gio.Cancellable | null): Call;
            /**
             * Asynchronously deletes a given #MMCall from the modem.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_voice_delete_call_finish() to get the result of the operation.
             *
             * See mm_modem_voice_delete_call_sync() for the synchronous, blocking version
             * of this method.
             * @param call Path of the #MMCall to delete.
             * @param cancellable A #GCancellable or %NULL.
             */
            delete_call(call: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously deletes a given #MMCall from the modem.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_voice_delete_call_finish() to get the result of the operation.
             *
             * See mm_modem_voice_delete_call_sync() for the synchronous, blocking version
             * of this method.
             * @param call Path of the #MMCall to delete.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            delete_call(
                call: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously deletes a given #MMCall from the modem.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_voice_delete_call_finish() to get the result of the operation.
             *
             * See mm_modem_voice_delete_call_sync() for the synchronous, blocking version
             * of this method.
             * @param call Path of the #MMCall to delete.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            delete_call(
                call: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_modem_voice_delete_call().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_voice_delete_call().
             * @returns %TRUE if the call was deleted, %FALSE if @error is set.
             */
            delete_call_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously deletes a given #MMCall from the modem.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_voice_delete_call() for the asynchronous version of this method.
             * @param call Path of the #MMCall to delete.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the CALL was deleted, %FALSE if @error is set.
             */
            delete_call_sync(call: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Gets a copy of the DBus path of the #MMObject object which implements this
             * interface.
             * @returns The DBus path of the #MMObject. The returned value should be freed with g_free().
             */
            dup_path(): string;
            /**
             * Checks whether emergency calls only are allowed.
             * @returns %TRUE if only emergency calls are allowed, %FALSE otherwise.
             */
            get_emergency_only(): boolean;
            /**
             * Gets the DBus path of the #MMObject which implements this interface.
             * @returns The DBus path of the #MMObject object.
             */
            get_path(): string;
            /**
             * Asynchronously hangs up all ongoing (active, waiting, held) calls.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_voice_hangup_all_finish() to get the result of the operation.
             *
             * See mm_modem_voice_hangup_all_sync() for the synchronous, blocking version of
             * this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            hangup_all(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously hangs up all ongoing (active, waiting, held) calls.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_voice_hangup_all_finish() to get the result of the operation.
             *
             * See mm_modem_voice_hangup_all_sync() for the synchronous, blocking version of
             * this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            hangup_all(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously hangs up all ongoing (active, waiting, held) calls.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_voice_hangup_all_finish() to get the result of the operation.
             *
             * See mm_modem_voice_hangup_all_sync() for the synchronous, blocking version of
             * this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            hangup_all(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_modem_voice_hangup_all().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_voice_hangup_all().
             * @returns %TRUE if the operation was successful, %FALSE if @error is set.
             */
            hangup_all_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously hangs up all ongoing (active, waiting, held) calls.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_voice_hangup_all() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the operation was successful, %FALSE if @error is set.
             */
            hangup_all_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously hangs up all active calls and accepts the next waiting or held
             * call.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_voice_hangup_and_accept_finish() to get the result of the operation.
             *
             * See mm_modem_voice_hangup_and_accept_sync() for the synchronous, blocking
             * version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            hangup_and_accept(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously hangs up all active calls and accepts the next waiting or held
             * call.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_voice_hangup_and_accept_finish() to get the result of the operation.
             *
             * See mm_modem_voice_hangup_and_accept_sync() for the synchronous, blocking
             * version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            hangup_and_accept(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously hangs up all active calls and accepts the next waiting or held
             * call.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_voice_hangup_and_accept_finish() to get the result of the operation.
             *
             * See mm_modem_voice_hangup_and_accept_sync() for the synchronous, blocking
             * version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            hangup_and_accept(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_modem_voice_hangup_and_accept().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_voice_hangup_and_accept().
             * @returns %TRUE if the operation was successful, %FALSE if @error is set.
             */
            hangup_and_accept_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously hangs up all active calls and accepts the next waiting or held
             * call.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_voice_hangup_and_accept() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the operation was successful, %FALSE if @error is set.
             */
            hangup_and_accept_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously puts all active calls on hold and accepts the next waiting or
             * held call.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_voice_hold_and_accept_finish() to get the result of the operation.
             *
             * See mm_modem_voice_hold_and_accept_sync() for the synchronous, blocking
             * version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            hold_and_accept(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously puts all active calls on hold and accepts the next waiting or
             * held call.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_voice_hold_and_accept_finish() to get the result of the operation.
             *
             * See mm_modem_voice_hold_and_accept_sync() for the synchronous, blocking
             * version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            hold_and_accept(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously puts all active calls on hold and accepts the next waiting or
             * held call.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_voice_hold_and_accept_finish() to get the result of the operation.
             *
             * See mm_modem_voice_hold_and_accept_sync() for the synchronous, blocking
             * version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            hold_and_accept(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_modem_voice_hold_and_accept().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_voice_hold_and_accept().
             * @returns %TRUE if the operation was successful, %FALSE if @error is set.
             */
            hold_and_accept_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously puts all active calls on hold and accepts the next waiting or
             * held call.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_voice_hold_and_accept() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the operation was successful, %FALSE if @error is set.
             */
            hold_and_accept_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously lists the #MMCall objects in the modem.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_voice_list_calls_finish() to get the result of the operation.
             *
             * See mm_modem_voice_list_calls_sync() for the synchronous, blocking version of
             * this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            list_calls(cancellable?: Gio.Cancellable | null): Promise<Call[]>;
            /**
             * Asynchronously lists the #MMCall objects in the modem.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_voice_list_calls_finish() to get the result of the operation.
             *
             * See mm_modem_voice_list_calls_sync() for the synchronous, blocking version of
             * this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            list_calls(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously lists the #MMCall objects in the modem.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_voice_list_calls_finish() to get the result of the operation.
             *
             * See mm_modem_voice_list_calls_sync() for the synchronous, blocking version of
             * this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            list_calls(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<Call[]> | void;
            /**
             * Finishes an operation started with mm_modem_voice_list_calls().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_voice_list_calls().
             * @returns A list of #MMCall objects, or #NULL if either not found or @error is set. The returned value should be freed with g_list_free_full() using g_object_unref() as #GDestroyNotify function.
             */
            list_calls_finish(res: Gio.AsyncResult): Call[];
            /**
             * Synchronously lists the #MMCall objects in the modem.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_voice_list_calls() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns A list of #MMCall objects, or #NULL if either not found or @error is set. The returned value should be freed with g_list_free_full() using g_object_unref() as #GDestroyNotify function.
             */
            list_calls_sync(cancellable?: Gio.Cancellable | null): Call[];
            /**
             * Asynchronously joins all active and held calls, and disconnects from them.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_voice_transfer_finish() to get the result of the operation.
             *
             * See mm_modem_voice_transfer_sync() for the synchronous, blocking version of
             * this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            transfer(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously joins all active and held calls, and disconnects from them.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_voice_transfer_finish() to get the result of the operation.
             *
             * See mm_modem_voice_transfer_sync() for the synchronous, blocking version of
             * this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            transfer(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously joins all active and held calls, and disconnects from them.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_modem_voice_transfer_finish() to get the result of the operation.
             *
             * See mm_modem_voice_transfer_sync() for the synchronous, blocking version of
             * this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            transfer(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_modem_voice_transfer().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_modem_voice_transfer().
             * @returns %TRUE if the operation was successful, %FALSE if @error is set.
             */
            transfer_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously joins all active and held calls, and disconnects from them.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_modem_voice_transfer() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the operation was successful, %FALSE if @error is set.
             */
            transfer_sync(cancellable?: Gio.Cancellable | null): boolean;

            // Inherited properties
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Voice.Calls">"Calls"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get calls(): string[];
            set calls(val: string[]);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Voice.EmergencyOnly">"EmergencyOnly"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get emergency_only(): boolean;
            set emergency_only(val: boolean);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Voice.EmergencyOnly">"EmergencyOnly"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get emergencyOnly(): boolean;
            set emergencyOnly(val: boolean);

            // Inherited methods
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            init_async(io_priority: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             * @returns %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present.
             */
            init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Finishes the async construction for the various g_async_initable_new
             * calls, returning the created object or %NULL on error.
             * @param res the #GAsyncResult from the callback
             * @returns a newly created #GObject,      or %NULL on error. Free with g_object_unref().
             */
            new_finish(res: Gio.AsyncResult): ModemVoice;
            // Conflicted with ModemManager.GdbusModemVoiceProxy.new_finish
            new_finish(...args: never[]): any;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            vfunc_init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             */
            vfunc_init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.CallWaitingQuery">CallWaitingQuery()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_call_waiting_query_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_call_waiting_query_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_call_waiting_query(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.CallWaitingQuery">CallWaitingQuery()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_call_waiting_query_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_call_waiting_query_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_call_waiting_query(
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.CallWaitingQuery">CallWaitingQuery()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_call_waiting_query_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_call_waiting_query_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_call_waiting_query(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_voice_call_call_waiting_query().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_voice_call_call_waiting_query().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_call_waiting_query_finish(res: Gio.AsyncResult): [boolean, boolean];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.CallWaitingQuery">CallWaitingQuery()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_voice_call_call_waiting_query() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_call_waiting_query_sync(cancellable?: Gio.Cancellable | null): [boolean, boolean];
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.CallWaitingSetup">CallWaitingSetup()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_call_waiting_setup_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_call_waiting_setup_sync() for the synchronous, blocking version of this method.
             * @param arg_enable Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_call_waiting_setup(arg_enable: boolean, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.CallWaitingSetup">CallWaitingSetup()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_call_waiting_setup_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_call_waiting_setup_sync() for the synchronous, blocking version of this method.
             * @param arg_enable Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_call_waiting_setup(
                arg_enable: boolean,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.CallWaitingSetup">CallWaitingSetup()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_call_waiting_setup_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_call_waiting_setup_sync() for the synchronous, blocking version of this method.
             * @param arg_enable Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_call_waiting_setup(
                arg_enable: boolean,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_voice_call_call_waiting_setup().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_voice_call_call_waiting_setup().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_call_waiting_setup_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.CallWaitingSetup">CallWaitingSetup()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_voice_call_call_waiting_setup() for the asynchronous version of this method.
             * @param arg_enable Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_call_waiting_setup_sync(arg_enable: boolean, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.CreateCall">CreateCall()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_create_call_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_create_call_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_create_call(arg_properties: GLib.Variant, cancellable?: Gio.Cancellable | null): Promise<string>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.CreateCall">CreateCall()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_create_call_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_create_call_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_create_call(
                arg_properties: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.CreateCall">CreateCall()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_create_call_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_create_call_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_create_call(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<string> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_voice_call_create_call().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_voice_call_create_call().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_create_call_finish(res: Gio.AsyncResult): [boolean, string];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.CreateCall">CreateCall()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_voice_call_create_call() for the asynchronous version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_create_call_sync(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
            ): [boolean, string];
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.DeleteCall">DeleteCall()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_delete_call_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_delete_call_sync() for the synchronous, blocking version of this method.
             * @param arg_path Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_delete_call(arg_path: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.DeleteCall">DeleteCall()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_delete_call_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_delete_call_sync() for the synchronous, blocking version of this method.
             * @param arg_path Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_delete_call(
                arg_path: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.DeleteCall">DeleteCall()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_delete_call_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_delete_call_sync() for the synchronous, blocking version of this method.
             * @param arg_path Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_delete_call(
                arg_path: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_voice_call_delete_call().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_voice_call_delete_call().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_delete_call_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.DeleteCall">DeleteCall()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_voice_call_delete_call() for the asynchronous version of this method.
             * @param arg_path Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_delete_call_sync(arg_path: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.HangupAll">HangupAll()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_hangup_all_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_hangup_all_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_hangup_all(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.HangupAll">HangupAll()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_hangup_all_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_hangup_all_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_hangup_all(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.HangupAll">HangupAll()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_hangup_all_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_hangup_all_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_hangup_all(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_voice_call_hangup_all().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_voice_call_hangup_all().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_hangup_all_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.HangupAll">HangupAll()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_voice_call_hangup_all() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_hangup_all_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.HangupAndAccept">HangupAndAccept()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_hangup_and_accept_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_hangup_and_accept_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_hangup_and_accept(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.HangupAndAccept">HangupAndAccept()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_hangup_and_accept_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_hangup_and_accept_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_hangup_and_accept(
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.HangupAndAccept">HangupAndAccept()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_hangup_and_accept_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_hangup_and_accept_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_hangup_and_accept(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_voice_call_hangup_and_accept().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_voice_call_hangup_and_accept().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_hangup_and_accept_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.HangupAndAccept">HangupAndAccept()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_voice_call_hangup_and_accept() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_hangup_and_accept_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.HoldAndAccept">HoldAndAccept()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_hold_and_accept_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_hold_and_accept_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_hold_and_accept(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.HoldAndAccept">HoldAndAccept()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_hold_and_accept_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_hold_and_accept_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_hold_and_accept(
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.HoldAndAccept">HoldAndAccept()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_hold_and_accept_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_hold_and_accept_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_hold_and_accept(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_voice_call_hold_and_accept().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_voice_call_hold_and_accept().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_hold_and_accept_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.HoldAndAccept">HoldAndAccept()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_voice_call_hold_and_accept() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_hold_and_accept_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.ListCalls">ListCalls()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_list_calls_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_list_calls_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_list_calls(cancellable?: Gio.Cancellable | null): Promise<string[] | null>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.ListCalls">ListCalls()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_list_calls_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_list_calls_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_list_calls(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.ListCalls">ListCalls()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_list_calls_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_list_calls_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_list_calls(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<string[] | null> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_voice_call_list_calls().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_voice_call_list_calls().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_list_calls_finish(res: Gio.AsyncResult): [boolean, string[] | null];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.ListCalls">ListCalls()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_voice_call_list_calls() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_list_calls_sync(cancellable?: Gio.Cancellable | null): [boolean, string[] | null];
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.Transfer">Transfer()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_transfer_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_transfer_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_transfer(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.Transfer">Transfer()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_transfer_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_transfer_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_transfer(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.Transfer">Transfer()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_transfer_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_transfer_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_transfer(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_voice_call_transfer().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_voice_call_transfer().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_transfer_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.Transfer">Transfer()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_voice_call_transfer() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_transfer_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.CallWaitingQuery">CallWaitingQuery()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param status Parameter to return.
             */
            complete_call_waiting_query(invocation: Gio.DBusMethodInvocation, status: boolean): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.CallWaitingSetup">CallWaitingSetup()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_call_waiting_setup(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.CreateCall">CreateCall()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param path Parameter to return.
             */
            complete_create_call(invocation: Gio.DBusMethodInvocation, path: string): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.DeleteCall">DeleteCall()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_delete_call(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.HangupAll">HangupAll()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_hangup_all(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.HangupAndAccept">HangupAndAccept()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_hangup_and_accept(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.HoldAndAccept">HoldAndAccept()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_hold_and_accept(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.ListCalls">ListCalls()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param result Parameter to return.
             */
            complete_list_calls(invocation: Gio.DBusMethodInvocation, result: string): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.Transfer">Transfer()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_transfer(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Emits the <link linkend="gdbus-signal-org-freedesktop-ModemManager1-Modem-Voice.CallAdded">"CallAdded"</link> D-Bus signal.
             * @param arg_path Argument to pass with the signal.
             */
            emit_call_added(arg_path: string): void;
            /**
             * Emits the <link linkend="gdbus-signal-org-freedesktop-ModemManager1-Modem-Voice.CallDeleted">"CallDeleted"</link> D-Bus signal.
             * @param arg_path Argument to pass with the signal.
             */
            emit_call_deleted(arg_path: string): void;
            vfunc_call_added(arg_path: string): void;
            vfunc_call_deleted(arg_path: string): void;
            vfunc_handle_call_waiting_query(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_call_waiting_setup(invocation: Gio.DBusMethodInvocation, arg_enable: boolean): boolean;
            vfunc_handle_create_call(invocation: Gio.DBusMethodInvocation, arg_properties: GLib.Variant): boolean;
            vfunc_handle_delete_call(invocation: Gio.DBusMethodInvocation, arg_path: string): boolean;
            vfunc_handle_hangup_all(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_hangup_and_accept(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_hold_and_accept(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_list_calls(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_transfer(invocation: Gio.DBusMethodInvocation): boolean;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace NetworkTimezone {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {}
        }

        /**
         * The #MMNetworkTimezone structure contains private data and should
         * only be accessed using the provided API.
         */
        class NetworkTimezone extends GObject.Object {
            static $gtype: GObject.GType<NetworkTimezone>;

            // Constructors

            constructor(properties?: Partial<NetworkTimezone.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Methods

            /**
             * Gets the timezone offset due to daylight saving time (in minutes) reported by
             * the network.
             * @returns the offset, or %MM_NETWORK_TIMEZONE_OFFSET_UNKNOWN if unknown.
             */
            get_dst_offset(): number;
            /**
             * Gets the number of leap seconds (TAI-UTC), as reported by the network.
             * @returns the number of leap seconds, or %MM_NETWORK_TIMEZONE_LEAP_SECONDS_UNKNOWN if unknown.
             */
            get_leap_seconds(): number;
            /**
             * Gets the timezone offset (in minutes) reported by the network.
             * @returns the offset, or %MM_NETWORK_TIMEZONE_OFFSET_UNKNOWN if unknown.
             */
            get_offset(): number;
        }

        namespace Nr5gRegistrationSettings {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {}
        }

        /**
         * The #MMNr5gRegistrationSettings structure contains private data and should only be accessed
         * using the provided API.
         */
        class Nr5gRegistrationSettings extends GObject.Object {
            static $gtype: GObject.GType<Nr5gRegistrationSettings>;

            // Constructors

            constructor(properties?: Partial<Nr5gRegistrationSettings.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static ['new'](): Nr5gRegistrationSettings;

            // Methods

            /**
             * Gets the MICO mode configuration.
             * @returns a #MMModem3gppDrxCycle.
             */
            get_drx_cycle(): Modem3gppDrxCycle;
            /**
             * Gets the MICO mode configuration.
             * @returns a #MMModem3gppMicoMode.
             */
            get_mico_mode(): Modem3gppMicoMode;
            /**
             * Sets the MICO mode configuration.
             * @param drx_cycle a #MMModem3gppDrxCycle.
             */
            set_drx_cycle(drx_cycle: Modem3gppDrxCycle | null): void;
            /**
             * Sets the MICO mode configuration.
             * @param mico_mode a #MMModem3gppMicoMode.
             */
            set_mico_mode(mico_mode: Modem3gppMicoMode | null): void;
        }

        namespace Object {
            // Constructor properties interface

            interface ConstructorProps
                extends GdbusObjectProxy.ConstructorProps,
                    Gio.DBusObject.ConstructorProps,
                    GdbusObject.ConstructorProps {}
        }

        /**
         * The #MMObject structure contains private data and should only be accessed
         * using the provided API.
         */
        class Object extends GdbusObjectProxy implements Gio.DBusObject, GdbusObject {
            static $gtype: GObject.GType<Object>;

            // Constructors

            constructor(properties?: Partial<Object.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Methods

            /**
             * Gets a copy of the DBus path of the #MMObject object.
             * @returns The DBus path of the #MMObject. The returned value should be freed with g_free().
             */
            dup_path(): string;
            /**
             * Gets the #MMModem instance for the D-Bus interface
             * org.freedesktop.ModemManager1.Modem on `self,` if any.
             * @returns A #MMModem that must be freed with g_object_unref() or %NULL if @self does not implement the interface.
             */
            get_modem(): Modem;
            // Conflicted with ModemManager.GdbusObject.get_modem
            get_modem(...args: never[]): any;
            /**
             * Gets the #MMModem3gpp instance for the D-Bus interface
             * org.freedesktop.ModemManager1.Modem.Modem3gpp on `self,` if any.
             * @returns A #MMModem3gpp that must be freed with g_object_unref() or %NULL if @self does not implement the interface.
             */
            get_modem_3gpp(): Modem3gpp;
            /**
             * Gets the #MMModem3gppProfileManager instance for the D-Bus interface
             * org.freedesktop.ModemManager1.Modem.Modem3gpp-ProfileManager on `self,` if any.
             * @returns A #MMModem3gppProfileManager that must be freed with g_object_unref() or %NULL if @self does not implement the interface.
             */
            get_modem_3gpp_profile_manager(): Modem3gppProfileManager;
            /**
             * Gets the #MMModem3gppUssd instance for the D-Bus interface
             * org.freedesktop.ModemManager1.Modem.Modem3gpp-Ussd on `self,` if any.
             * @returns A #MMModem3gppUssd that must be freed with g_object_unref() or %NULL if @self does not implement the interface.
             */
            get_modem_3gpp_ussd(): Modem3gppUssd;
            /**
             * Gets the #MMModemCdma instance for the D-Bus interface
             * org.freedesktop.ModemManager1.Modem.ModemCdma on `self,` if any.
             * @returns A #MMModemCdma that must be freed with g_object_unref() or %NULL if @self does not implement the interface.
             */
            get_modem_cdma(): ModemCdma;
            // Conflicted with ModemManager.GdbusObject.get_modem_cdma
            get_modem_cdma(...args: never[]): any;
            /**
             * Gets the #MMModemFirmware instance for the D-Bus interface
             * org.freedesktop.ModemManager1.Modem.Firmware on `self,` if any.
             * @returns A #MMModemFirmware that must be freed with g_object_unref() or %NULL if @self does not implement the interface.
             */
            get_modem_firmware(): ModemFirmware;
            // Conflicted with ModemManager.GdbusObject.get_modem_firmware
            get_modem_firmware(...args: never[]): any;
            /**
             * Gets the #MMModemLocation instance for the D-Bus interface
             * org.freedesktop.ModemManager1.Modem.Modemlocation on `self,` if any.
             * @returns A #MMModemLocation that must be freed with g_object_unref() or %NULL if @self does not implement the interface.
             */
            get_modem_location(): ModemLocation;
            // Conflicted with ModemManager.GdbusObject.get_modem_location
            get_modem_location(...args: never[]): any;
            /**
             * Gets the #MMModemMessaging instance for the D-Bus interface
             * org.freedesktop.ModemManager1.Modem.Modemmessaging on `self,` if any.
             * @returns A #MMModemMessaging that must be freed with g_object_unref() or %NULL if @self does not implement the interface.
             */
            get_modem_messaging(): ModemMessaging;
            // Conflicted with ModemManager.GdbusObject.get_modem_messaging
            get_modem_messaging(...args: never[]): any;
            /**
             * Gets the #MMModemOma instance for the D-Bus interface
             * org.freedesktop.ModemManager1.Modem.Oma on `self,` if any.
             * @returns A #MMModemOma that must be freed with g_object_unref() or %NULL if @self does not implement the interface.
             */
            get_modem_oma(): ModemOma;
            // Conflicted with ModemManager.GdbusObject.get_modem_oma
            get_modem_oma(...args: never[]): any;
            /**
             * Gets the #MMModemSar instance for the D-Bus interface
             * org.freedesktop.ModemManager1.Modem.Sar on `self,` if any.
             * @returns A #MMModemSar that must be freed with g_object_unref() or %NULL if @self does not implement the interface.
             */
            get_modem_sar(): ModemSar;
            // Conflicted with ModemManager.GdbusObject.get_modem_sar
            get_modem_sar(...args: never[]): any;
            /**
             * Gets the #MMModemSignal instance for the D-Bus interface
             * org.freedesktop.ModemManager1.Modem.Signal on `self,` if any.
             * @returns A #MMModemSignal that must be freed with g_object_unref() or %NULL if @self does not implement the interface.
             */
            get_modem_signal(): ModemSignal;
            // Conflicted with ModemManager.GdbusObject.get_modem_signal
            get_modem_signal(...args: never[]): any;
            /**
             * Gets the #MMModemSimple instance for the D-Bus interface
             * org.freedesktop.ModemManager1.Modem.Modemsimple on `self,` if any.
             * @returns A #MMModemSimple that must be freed with g_object_unref() or %NULL if @self does not implement the interface.
             */
            get_modem_simple(): ModemSimple;
            // Conflicted with ModemManager.GdbusObject.get_modem_simple
            get_modem_simple(...args: never[]): any;
            /**
             * Gets the #MMModemTime instance for the D-Bus interface
             * org.freedesktop.ModemManager1.Modem.Time on `self,` if any.
             * @returns A #MMModemTime that must be freed with g_object_unref() or %NULL if @self does not implement the interface.
             */
            get_modem_time(): ModemTime;
            // Conflicted with ModemManager.GdbusObject.get_modem_time
            get_modem_time(...args: never[]): any;
            /**
             * Gets the #MMModemVoice instance for the D-Bus interface
             * org.freedesktop.ModemManager1.Modem.Modemvoice on `self,` if any.
             * @returns A #MMModemVoice that must be freed with g_object_unref() or %NULL if @self does not implement the interface.
             */
            get_modem_voice(): ModemVoice;
            // Conflicted with ModemManager.GdbusObject.get_modem_voice
            get_modem_voice(...args: never[]): any;

            // Inherited properties
            /**
             * The #MmGdbusModem instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem.top_of_page">org.freedesktop.ModemManager1.Modem</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem(): GdbusModem;
            set modem(val: GdbusModem);
            /**
             * The #MmGdbusModemCdma instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-ModemCdma.top_of_page">org.freedesktop.ModemManager1.Modem.ModemCdma</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem_cdma(): GdbusModemCdma;
            set modem_cdma(val: GdbusModemCdma);
            /**
             * The #MmGdbusModemCdma instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-ModemCdma.top_of_page">org.freedesktop.ModemManager1.Modem.ModemCdma</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modemCdma(): GdbusModemCdma;
            set modemCdma(val: GdbusModemCdma);
            /**
             * The #MmGdbusModemFirmware instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Firmware.top_of_page">org.freedesktop.ModemManager1.Modem.Firmware</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem_firmware(): GdbusModemFirmware;
            set modem_firmware(val: GdbusModemFirmware);
            /**
             * The #MmGdbusModemFirmware instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Firmware.top_of_page">org.freedesktop.ModemManager1.Modem.Firmware</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modemFirmware(): GdbusModemFirmware;
            set modemFirmware(val: GdbusModemFirmware);
            /**
             * The #MmGdbusModemLocation instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Location.top_of_page">org.freedesktop.ModemManager1.Modem.Location</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem_location(): GdbusModemLocation;
            set modem_location(val: GdbusModemLocation);
            /**
             * The #MmGdbusModemLocation instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Location.top_of_page">org.freedesktop.ModemManager1.Modem.Location</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modemLocation(): GdbusModemLocation;
            set modemLocation(val: GdbusModemLocation);
            /**
             * The #MmGdbusModemMessaging instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Messaging.top_of_page">org.freedesktop.ModemManager1.Modem.Messaging</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem_messaging(): GdbusModemMessaging;
            set modem_messaging(val: GdbusModemMessaging);
            /**
             * The #MmGdbusModemMessaging instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Messaging.top_of_page">org.freedesktop.ModemManager1.Modem.Messaging</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modemMessaging(): GdbusModemMessaging;
            set modemMessaging(val: GdbusModemMessaging);
            /**
             * The #MmGdbusModemOma instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Oma.top_of_page">org.freedesktop.ModemManager1.Modem.Oma</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem_oma(): GdbusModemOma;
            set modem_oma(val: GdbusModemOma);
            /**
             * The #MmGdbusModemOma instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Oma.top_of_page">org.freedesktop.ModemManager1.Modem.Oma</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modemOma(): GdbusModemOma;
            set modemOma(val: GdbusModemOma);
            /**
             * The #MmGdbusModemSar instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Sar.top_of_page">org.freedesktop.ModemManager1.Modem.Sar</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem_sar(): GdbusModemSar;
            set modem_sar(val: GdbusModemSar);
            /**
             * The #MmGdbusModemSar instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Sar.top_of_page">org.freedesktop.ModemManager1.Modem.Sar</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modemSar(): GdbusModemSar;
            set modemSar(val: GdbusModemSar);
            /**
             * The #MmGdbusModemSignal instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Signal.top_of_page">org.freedesktop.ModemManager1.Modem.Signal</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem_signal(): GdbusModemSignal;
            set modem_signal(val: GdbusModemSignal);
            /**
             * The #MmGdbusModemSignal instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Signal.top_of_page">org.freedesktop.ModemManager1.Modem.Signal</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modemSignal(): GdbusModemSignal;
            set modemSignal(val: GdbusModemSignal);
            /**
             * The #MmGdbusModemSimple instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Simple.top_of_page">org.freedesktop.ModemManager1.Modem.Simple</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem_simple(): GdbusModemSimple;
            set modem_simple(val: GdbusModemSimple);
            /**
             * The #MmGdbusModemSimple instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Simple.top_of_page">org.freedesktop.ModemManager1.Modem.Simple</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modemSimple(): GdbusModemSimple;
            set modemSimple(val: GdbusModemSimple);
            /**
             * The #MmGdbusModemTime instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Time.top_of_page">org.freedesktop.ModemManager1.Modem.Time</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem_time(): GdbusModemTime;
            set modem_time(val: GdbusModemTime);
            /**
             * The #MmGdbusModemTime instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Time.top_of_page">org.freedesktop.ModemManager1.Modem.Time</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modemTime(): GdbusModemTime;
            set modemTime(val: GdbusModemTime);
            /**
             * The #MmGdbusModemVoice instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Voice.top_of_page">org.freedesktop.ModemManager1.Modem.Voice</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem_voice(): GdbusModemVoice;
            set modem_voice(val: GdbusModemVoice);
            /**
             * The #MmGdbusModemVoice instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Voice.top_of_page">org.freedesktop.ModemManager1.Modem.Voice</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modemVoice(): GdbusModemVoice;
            set modemVoice(val: GdbusModemVoice);
            /**
             * The #MmGdbusModem3gpp instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Modem3gpp.top_of_page">org.freedesktop.ModemManager1.Modem.Modem3gpp</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem3gpp(): GdbusModem3gpp;
            set modem3gpp(val: GdbusModem3gpp);
            /**
             * The #MmGdbusModem3gppProfileManager instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.top_of_page">org.freedesktop.ModemManager1.Modem.Modem3gpp.ProfileManager</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem3gpp_profile_manager(): GdbusModem3gppProfileManager;
            set modem3gpp_profile_manager(val: GdbusModem3gppProfileManager);
            /**
             * The #MmGdbusModem3gppProfileManager instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.top_of_page">org.freedesktop.ModemManager1.Modem.Modem3gpp.ProfileManager</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem3gppProfileManager(): GdbusModem3gppProfileManager;
            set modem3gppProfileManager(val: GdbusModem3gppProfileManager);
            /**
             * The #MmGdbusModem3gppUssd instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.top_of_page">org.freedesktop.ModemManager1.Modem.Modem3gpp.Ussd</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem3gpp_ussd(): GdbusModem3gppUssd;
            set modem3gpp_ussd(val: GdbusModem3gppUssd);
            /**
             * The #MmGdbusModem3gppUssd instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.top_of_page">org.freedesktop.ModemManager1.Modem.Modem3gpp.Ussd</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem3gppUssd(): GdbusModem3gppUssd;
            set modem3gppUssd(val: GdbusModem3gppUssd);

            // Inherited methods
            /**
             * Gets the #MmGdbusModem3gpp instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Modem3gpp.top_of_page">org.freedesktop.ModemManager1.Modem.Modem3gpp</link> on `object,` if any.
             * @returns A #MmGdbusModem3gpp that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
             */
            get_modem3gpp(): GdbusModem3gpp | null;
            /**
             * Gets the #MmGdbusModem3gppProfileManager instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.top_of_page">org.freedesktop.ModemManager1.Modem.Modem3gpp.ProfileManager</link> on `object,` if any.
             * @returns A #MmGdbusModem3gppProfileManager that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
             */
            get_modem3gpp_profile_manager(): GdbusModem3gppProfileManager | null;
            /**
             * Gets the #MmGdbusModem3gppUssd instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.top_of_page">org.freedesktop.ModemManager1.Modem.Modem3gpp.Ussd</link> on `object,` if any.
             * @returns A #MmGdbusModem3gppUssd that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
             */
            get_modem3gpp_ussd(): GdbusModem3gppUssd | null;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace Pco {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {}
        }

        /**
         * The #MMPco structure contains private data and should only be accessed
         * using the provided API.
         */
        class Pco extends GObject.Object {
            static $gtype: GObject.GType<Pco>;

            // Constructors

            constructor(properties?: Partial<Pco.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Static methods

            /**
             * Frees all of the memory used by a #GList of #MMPco.
             * @param pco_list a #GList of  #MMPco.
             */
            static list_free(pco_list: Pco[]): void;

            // Methods

            /**
             * Gets the PCO data in raw bytes.
             * @returns the PCO data, or %NULL if it doesn't contain any.
             */
            get_data(): [number, number];
            // Conflicted with GObject.Object.get_data
            get_data(...args: never[]): any;
            /**
             * Gets the session ID associated with the PCO.
             * @returns the session ID.
             */
            get_session_id(): number;
            /**
             * Gets the complete flag that indicates whether the PCO data contains the
             * complete PCO structure received from the network.
             * @returns %TRUE if the PCO data contains the complete PCO structure, %FALSE otherwise.
             */
            is_complete(): boolean;
        }

        namespace Signal {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {}
        }

        /**
         * The #MMSignal structure contains private data and should
         * only be accessed using the provided API.
         */
        class Signal extends GObject.Object {
            static $gtype: GObject.GType<Signal>;

            // Constructors

            constructor(properties?: Partial<Signal.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Methods

            /**
             * Gets the Ec/Io, in dB.
             *
             * Only applicable to CDMA1x, CDMA EV-DO and UMTS (WCDMA).
             * @returns the ECIO, or %MM_SIGNAL_UNKNOWN if unknown.
             */
            get_ecio(): number;
            /**
             * Gets the channel error rate (BER, BLER,... depends on the RAT), in
             * percentage.
             *
             * Applicable to all RAT.
             * @returns the error rate, or %MM_SIGNAL_UNKNOWN if unknown.
             */
            get_error_rate(): number;
            /**
             * Gets the Io, in dBm.
             *
             * Only applicable to CDMA EV-DO.
             * @returns the Io, or %MM_SIGNAL_UNKNOWN if unknown.
             */
            get_io(): number;
            /**
             * Gets the RSCP (Received Signal Code Power), in dBm.
             * @returns the RSCP, or %MM_SIGNAL_UNKNOWN if unknown.
             */
            get_rscp(): number;
            /**
             * Gets the RSRP (Reference Signal Received Power), in dBm.
             *
             * Only applicable to LTE.
             * @returns the RSRP, or %MM_SIGNAL_UNKNOWN if unknown.
             */
            get_rsrp(): number;
            /**
             * Gets the RSRQ (Reference Signal Received Quality), in dB.
             *
             * Only applicable to LTE.
             * @returns the RSRQ, or %MM_SIGNAL_UNKNOWN if unknown.
             */
            get_rsrq(): number;
            /**
             * Gets the RSSI (Received Signal Strength Indication), in dBm.
             * @returns the RSSI, or %MM_SIGNAL_UNKNOWN if unknown.
             */
            get_rssi(): number;
            /**
             * Gets the SINR level, in dB.
             *
             * Only applicable to CDMA EV-DO.
             * @returns the SINR, or %MM_SIGNAL_UNKNOWN if unknown.
             */
            get_sinr(): number;
            /**
             * Gets the S/R ration, in dB.
             *
             * Only applicable to LTE.
             * @returns the S/R ratio, or %MM_SIGNAL_UNKNOWN if unknown.
             */
            get_snr(): number;
        }

        namespace SignalThresholdProperties {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {}
        }

        /**
         * The #MMSignalThresholdProperties structure contains private data and should
         * only be accessed using the provided API.
         */
        class SignalThresholdProperties extends GObject.Object {
            static $gtype: GObject.GType<SignalThresholdProperties>;

            // Constructors

            constructor(properties?: Partial<SignalThresholdProperties.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static ['new'](): SignalThresholdProperties;

            // Methods

            /**
             * Gets whether the error rate threshold is enabled or disabled.
             * @returns %TRUE if the error rate threshold is enabled, %FALSE otherwise.
             */
            get_error_rate(): boolean;
            /**
             * Gets the RSSI threshold, in dBm.
             * @returns the RSSI threshold, or 0 if disabled.
             */
            get_rssi(): number;
            /**
             * Enables or disables the error rate threshold.
             * @param error_rate_threshold %TRUE to enable, %FALSE to disable.
             */
            set_error_rate(error_rate_threshold: boolean): void;
            /**
             * Sets the RSSI threshold, in dBm.
             * @param rssi_threshold the RSSI threshold, or 0 to disable.
             */
            set_rssi(rssi_threshold: number): void;
        }

        namespace Sim {
            // Constructor properties interface

            interface ConstructorProps
                extends GdbusSimProxy.ConstructorProps,
                    Gio.AsyncInitable.ConstructorProps,
                    Gio.DBusInterface.ConstructorProps,
                    Gio.Initable.ConstructorProps,
                    GdbusSim.ConstructorProps {}
        }

        /**
         * The #MMSim structure contains private data and should only be accessed
         * using the provided API.
         */
        class Sim extends GdbusSimProxy implements Gio.AsyncInitable<Sim>, Gio.DBusInterface, Gio.Initable, GdbusSim {
            static $gtype: GObject.GType<Sim>;

            // Constructors

            constructor(properties?: Partial<Sim.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Methods

            /**
             * Asynchronously changes the PIN code in the SIM card.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_sim_change_pin_finish() to get the result of the operation.
             *
             * See mm_sim_change_pin_sync() for the synchronous, blocking version of this
             * method.
             * @param old_pin The current PIN code.
             * @param new_pin The new PIN code to be set.
             * @param cancellable A #GCancellable or %NULL.
             */
            change_pin(old_pin: string, new_pin: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously changes the PIN code in the SIM card.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_sim_change_pin_finish() to get the result of the operation.
             *
             * See mm_sim_change_pin_sync() for the synchronous, blocking version of this
             * method.
             * @param old_pin The current PIN code.
             * @param new_pin The new PIN code to be set.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            change_pin(
                old_pin: string,
                new_pin: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously changes the PIN code in the SIM card.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_sim_change_pin_finish() to get the result of the operation.
             *
             * See mm_sim_change_pin_sync() for the synchronous, blocking version of this
             * method.
             * @param old_pin The current PIN code.
             * @param new_pin The new PIN code to be set.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            change_pin(
                old_pin: string,
                new_pin: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_sim_change_pin().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_sim_change_pin().
             * @returns %TRUE if the operation succeeded, %FALSE if @error is set.
             */
            change_pin_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously changes the PIN code in the SIM card.
             *
             * The calling thread is blocked until a reply is received.
             * See mm_sim_change_pin() for the asynchronous version of this method.
             * @param old_pin The current PIN code.
             * @param new_pin The new PIN code to be set.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the operation succeeded, %FALSE if @error is set.
             */
            change_pin_sync(old_pin: string, new_pin: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously disables requesting the PIN code in the SIM card.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_sim_disable_pin_finish() to get the result of the operation.
             *
             * See mm_sim_disable_pin_sync() for the synchronous, blocking version of this
             * method.
             * @param pin The PIN code.
             * @param cancellable A #GCancellable or %NULL.
             */
            disable_pin(pin: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously disables requesting the PIN code in the SIM card.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_sim_disable_pin_finish() to get the result of the operation.
             *
             * See mm_sim_disable_pin_sync() for the synchronous, blocking version of this
             * method.
             * @param pin The PIN code.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            disable_pin(
                pin: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously disables requesting the PIN code in the SIM card.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_sim_disable_pin_finish() to get the result of the operation.
             *
             * See mm_sim_disable_pin_sync() for the synchronous, blocking version of this
             * method.
             * @param pin The PIN code.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            disable_pin(
                pin: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_sim_disable_pin().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_sim_disable_pin().
             * @returns %TRUE if the operation succeeded, %FALSE if @error is set.
             */
            disable_pin_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously disables requesting the PIN code in the SIM card.
             *
             * The calling thread is blocked until a reply is received.
             * See mm_sim_disable_pin() for the asynchronous version of this method.
             * @param pin The PIN code.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the operation succeeded, %FALSE if @error is set.
             */
            disable_pin_sync(pin: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Gets a copy of the Embedded UICC ID (EID) of the #MMSim object.
             * @returns The EID of the #MMSim object, or %NULL if it couldn't be retrieved. The returned value should be freed with g_free().
             */
            dup_eid(): string;
            /**
             * Gets a copy of the list of emergency call numbers programmed in the SIM card.
             * @returns The emergency numbers, or %NULL if none available. The returned value should be freed with g_strfreev().
             */
            dup_emergency_numbers(): string[];
            /**
             * Gets the Group Identifier Level 1 of the #MMSim object.
             * @returns The GID1 data, or %NULL if unknown.
             */
            dup_gid1(): Uint8Array;
            /**
             * Gets the Group Identifier Level 2 of the #MMSim object.
             * @returns The GID2 data, or %NULL if unknown.
             */
            dup_gid2(): Uint8Array;
            /**
             * Gets a copy of the unique SIM identifier of the #MMSim object.
             * @returns The unique identifier of the #MMSim object, or %NULL if it couldn't be retrieved. The returned value should be freed with g_free().
             */
            dup_identifier(): string;
            /**
             * Gets a copy of the International Mobile Subscriber Identity (IMSI) of the
             * #MMSim object.
             * @returns The IMSI of the #MMSim object, or %NULL if it couldn't be retrieved. The returned value should be freed with g_free().
             */
            dup_imsi(): string;
            /**
             * Gets a copy of the Operator Identifier of the #MMSim object.
             * @returns The Operator Identifier of the #MMSim object, or %NULL if it couldn't be retrieved. The returned value should be freed with g_free().
             */
            dup_operator_identifier(): string;
            /**
             * Gets a copy of the Operator Name of the #MMSim object.
             * @returns The Operator Name of the #MMSim object, or %NULL if it couldn't be retrieved. The returned value should be freed with g_free().
             */
            dup_operator_name(): string;
            /**
             * Gets a copy of the DBus path of the #MMSim object.
             * @returns The DBus path of the #MMSim object. The returned value should be freed with g_free().
             */
            dup_path(): string;
            /**
             * Asynchronously enables requesting the PIN code in the SIM card.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_sim_enable_pin_finish() to get the result of the operation.
             *
             * See mm_sim_enable_pin_sync() for the synchronous, blocking version of this
             * method.
             * @param pin The PIN code.
             * @param cancellable A #GCancellable or %NULL.
             */
            enable_pin(pin: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously enables requesting the PIN code in the SIM card.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_sim_enable_pin_finish() to get the result of the operation.
             *
             * See mm_sim_enable_pin_sync() for the synchronous, blocking version of this
             * method.
             * @param pin The PIN code.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            enable_pin(
                pin: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously enables requesting the PIN code in the SIM card.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_sim_enable_pin_finish() to get the result of the operation.
             *
             * See mm_sim_enable_pin_sync() for the synchronous, blocking version of this
             * method.
             * @param pin The PIN code.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            enable_pin(
                pin: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_sim_enable_pin().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_sim_enable_pin().
             * @returns %TRUE if the operation succeeded, %FALSE if @error is set.
             */
            enable_pin_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously enables requesting the PIN code in the SIM card.
             *
             * The calling thread is blocked until a reply is received.
             * See mm_sim_enable_pin() for the asynchronous version of this method.
             * @param pin The PIN code.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the operation succeeded, %FALSE if @error is set.
             */
            enable_pin_sync(pin: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Checks whether the #MMSim is currently active.
             * @returns %TRUE if the SIM is active, %FALSE otherwise.
             */
            get_active(): boolean;
            /**
             * Gets the Embedded UICC ID (or EID) of the #MMSim object.
             *
             * <warning>The returned value is only valid until the property changes so it is
             * only safe to use this function on the thread where `self` was constructed. Use
             * mm_sim_dup_eid() if on another thread.</warning>
             * @returns The EID of the #MMSim object, or %NULL if it couldn't be retrieved.
             */
            get_eid(): string;
            /**
             * Gets the list of emergency call numbers programmed in the SIM card.
             *
             * <warning>The returned value is only valid until the property changes so it is
             * only safe to use this function on the thread where `self` was constructed. Use
             * mm_sim_dup_emergency_numbers() if on another thread.</warning>
             * @returns The emergency numbers, or %NULL if none available. Do not free the returned value, it belongs to @self.
             */
            get_emergency_numbers(): string[];
            /**
             * Gets the eSIM status.
             *
             * Only applicable if the SIM type is %MM_SIM_TYPE_ESIM.
             * @returns a #MMSimEsimStatus.
             */
            get_esim_status(): SimEsimStatus;
            /**
             * Gets the Group Identifier Level 1 of the #MMSim object.
             * @returns The GID1 data, or %NULL if unknown.
             */
            get_gid1(): Uint8Array;
            /**
             * Gets the Group Identifier Level 2 of the #MMSim object.
             * @returns The GID2 data, or %NULL if unknown.
             */
            get_gid2(): Uint8Array;
            /**
             * Gets the unique SIM identifier of the #MMSim object.
             *
             * <warning>The returned value is only valid until the property changes so it is
             * only safe to use this function on the thread where `self` was constructed. Use
             * mm_sim_dup_identifier() if on another thread.</warning>
             * @returns The unique identifier of the #MMSim object, or %NULL if it couldn't be retrieved.
             */
            get_identifier(): string;
            /**
             * Gets the International Mobile Subscriber Identity (IMSI) of the #MMSim
             * object.
             *
             * <warning>The returned value is only valid until the property changes so it is
             * only safe to use this function on the thread where `self` was constructed. Use
             * mm_sim_dup_imsi() if on another thread.</warning>
             * @returns The IMSI of the #MMSim object, or %NULL if it couldn't be retrieved.
             */
            get_imsi(): string;
            /**
             * Gets the Operator Identifier of the #MMSim object.
             *
             * <warning>The returned value is only valid until the property changes so it is
             * only safe to use this function on the thread where `self` was constructed. Use
             * mm_sim_dup_operator_identifier() if on another thread.</warning>
             * @returns The Operator Identifier of the #MMSim object, or %NULL if it couldn't be retrieved.
             */
            get_operator_identifier(): string;
            /**
             * Gets the Operator Name of the #MMSim object.
             *
             * <warning>The returned value is only valid until the property changes so it is
             * only safe to use this function on the thread where `self` was constructed. Use
             * mm_sim_dup_operator_name() if on another thread.</warning>
             * @returns The Operator Name of the #MMSim object, or %NULL if it couldn't be retrieved.
             */
            get_operator_name(): string;
            /**
             * Gets the DBus path of the #MMSim object.
             * @returns The DBus path of the #MMSim object.
             */
            get_path(): string;
            /**
             * Gets the list of #MMSimPreferredNetwork objects exposed by this
             * #MMSim.
             * @returns a list of #MMSimPreferredNetwork objects, or #NULL. The returned value should be freed with g_list_free_full() using mm_sim_preferred_network_free() as #GDestroyNotify function.
             */
            get_preferred_networks(): SimPreferredNetwork[];
            /**
             * Gets whether the SIM is removable or not.
             * @returns a #MMSimRemovability.
             */
            get_removability(): SimRemovability;
            /**
             * Gets the SIM type.
             * @returns a #MMSimType.
             */
            get_sim_type(): SimType;
            /**
             * Asynchronously sends the PIN code to the SIM card.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_sim_send_pin_finish() to get the result of the operation.
             *
             * See mm_sim_send_pin_sync() for the synchronous, blocking version of this
             * method.
             * @param pin The PIN code.
             * @param cancellable A #GCancellable or %NULL.
             */
            send_pin(pin: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously sends the PIN code to the SIM card.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_sim_send_pin_finish() to get the result of the operation.
             *
             * See mm_sim_send_pin_sync() for the synchronous, blocking version of this
             * method.
             * @param pin The PIN code.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            send_pin(
                pin: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously sends the PIN code to the SIM card.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_sim_send_pin_finish() to get the result of the operation.
             *
             * See mm_sim_send_pin_sync() for the synchronous, blocking version of this
             * method.
             * @param pin The PIN code.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            send_pin(
                pin: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_sim_send_pin().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_sim_send_pin().
             * @returns %TRUE if the operation succeeded, %FALSE if @error is set.
             */
            send_pin_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously sends the PIN to the SIM card.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_sim_send_pin() for the asynchronous version of this method.
             * @param pin The PIN code.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the operation succeeded, %FALSE if @error is set.
             */
            send_pin_sync(pin: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously sends the PUK code to the SIM card.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_sim_send_puk_finish() to get the result of the operation.
             *
             * See mm_sim_send_puk_sync() for the synchronous, blocking version of this
             * method.
             * @param puk The PUK code.
             * @param pin The PIN code.
             * @param cancellable A #GCancellable or %NULL.
             */
            send_puk(puk: string, pin: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously sends the PUK code to the SIM card.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_sim_send_puk_finish() to get the result of the operation.
             *
             * See mm_sim_send_puk_sync() for the synchronous, blocking version of this
             * method.
             * @param puk The PUK code.
             * @param pin The PIN code.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            send_puk(
                puk: string,
                pin: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously sends the PUK code to the SIM card.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_sim_send_puk_finish() to get the result of the operation.
             *
             * See mm_sim_send_puk_sync() for the synchronous, blocking version of this
             * method.
             * @param puk The PUK code.
             * @param pin The PIN code.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            send_puk(
                puk: string,
                pin: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_sim_send_puk().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_sim_send_puk().
             * @returns %TRUE if the operation succeeded, %FALSE if @error is set.
             */
            send_puk_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously sends the PUK to the SIM card.
             *
             * The calling thread is blocked until a reply is received.
             * See mm_sim_send_puk() for the asynchronous version of this method.
             * @param puk The PUK code.
             * @param pin The PIN code.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the operation succeeded, %FALSE if @error is set.
             */
            send_puk_sync(puk: string, pin: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously sets the preferred network list of this #MMSim.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_sim_set_preferred_networks_finish() to get the result of
             * the operation.
             * @param preferred_networks A list of #MMSimPreferredNetwork objects
             * @param cancellable A #GCancellable or %NULL.
             */
            set_preferred_networks(
                preferred_networks: SimPreferredNetwork[],
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronously sets the preferred network list of this #MMSim.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_sim_set_preferred_networks_finish() to get the result of
             * the operation.
             * @param preferred_networks A list of #MMSimPreferredNetwork objects
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            set_preferred_networks(
                preferred_networks: SimPreferredNetwork[],
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously sets the preferred network list of this #MMSim.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_sim_set_preferred_networks_finish() to get the result of
             * the operation.
             * @param preferred_networks A list of #MMSimPreferredNetwork objects
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            set_preferred_networks(
                preferred_networks: SimPreferredNetwork[],
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_sim_set_preferred_networks().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_sim_set_preferred_networks().
             * @returns %TRUE if the operation was successful, %FALSE if @error is set.
             */
            set_preferred_networks_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously sets the preferred network list of this #MMSim.
             *
             * The calling thread is blocked until a reply is received. See
             * mm_sim_set_preferred_networks() for the asynchronous
             * version of this method.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_sim_set_preferred_networks_finish() to get the result of
             * the operation.
             * @param preferred_networks A list of #MMSimPreferredNetwork objects
             * @param cancellable A #GCancellable or %NULL.
             */
            set_preferred_networks_sync(
                preferred_networks: SimPreferredNetwork[],
                cancellable?: Gio.Cancellable | null,
            ): boolean;

            // Inherited properties
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.Active">"Active"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get active(): boolean;
            set active(val: boolean);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.Eid">"Eid"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get eid(): string;
            set eid(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.EmergencyNumbers">"EmergencyNumbers"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get emergency_numbers(): string[];
            set emergency_numbers(val: string[]);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.EmergencyNumbers">"EmergencyNumbers"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get emergencyNumbers(): string[];
            set emergencyNumbers(val: string[]);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.EsimStatus">"EsimStatus"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get esim_status(): number;
            set esim_status(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.EsimStatus">"EsimStatus"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get esimStatus(): number;
            set esimStatus(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.Gid1">"Gid1"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get gid1(): GLib.Variant;
            set gid1(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.Gid2">"Gid2"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get gid2(): GLib.Variant;
            set gid2(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.Imsi">"Imsi"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get imsi(): string;
            set imsi(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.OperatorIdentifier">"OperatorIdentifier"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get operator_identifier(): string;
            set operator_identifier(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.OperatorIdentifier">"OperatorIdentifier"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get operatorIdentifier(): string;
            set operatorIdentifier(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.OperatorName">"OperatorName"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get operator_name(): string;
            set operator_name(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.OperatorName">"OperatorName"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get operatorName(): string;
            set operatorName(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.PreferredNetworks">"PreferredNetworks"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get preferred_networks(): GLib.Variant;
            set preferred_networks(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.PreferredNetworks">"PreferredNetworks"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get preferredNetworks(): GLib.Variant;
            set preferredNetworks(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.Removability">"Removability"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get removability(): number;
            set removability(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.SimIdentifier">"SimIdentifier"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get sim_identifier(): string;
            set sim_identifier(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.SimIdentifier">"SimIdentifier"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get simIdentifier(): string;
            set simIdentifier(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.SimType">"SimType"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get sim_type(): number;
            set sim_type(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.SimType">"SimType"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get simType(): number;
            set simType(val: number);

            // Inherited methods
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            init_async(io_priority: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             * @returns %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present.
             */
            init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Finishes the async construction for the various g_async_initable_new
             * calls, returning the created object or %NULL on error.
             * @param res the #GAsyncResult from the callback
             * @returns a newly created #GObject,      or %NULL on error. Free with g_object_unref().
             */
            new_finish(res: Gio.AsyncResult): Sim;
            // Conflicted with ModemManager.GdbusSimProxy.new_finish
            new_finish(...args: never[]): any;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            vfunc_init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             */
            vfunc_init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.ChangePin">ChangePin()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_call_change_pin_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_call_change_pin_sync() for the synchronous, blocking version of this method.
             * @param arg_old_pin Argument to pass with the method invocation.
             * @param arg_new_pin Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_change_pin(
                arg_old_pin: string,
                arg_new_pin: string,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.ChangePin">ChangePin()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_call_change_pin_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_call_change_pin_sync() for the synchronous, blocking version of this method.
             * @param arg_old_pin Argument to pass with the method invocation.
             * @param arg_new_pin Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_change_pin(
                arg_old_pin: string,
                arg_new_pin: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.ChangePin">ChangePin()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_call_change_pin_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_call_change_pin_sync() for the synchronous, blocking version of this method.
             * @param arg_old_pin Argument to pass with the method invocation.
             * @param arg_new_pin Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_change_pin(
                arg_old_pin: string,
                arg_new_pin: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_sim_call_change_pin().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_sim_call_change_pin().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_change_pin_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.ChangePin">ChangePin()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_sim_call_change_pin() for the asynchronous version of this method.
             * @param arg_old_pin Argument to pass with the method invocation.
             * @param arg_new_pin Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_change_pin_sync(
                arg_old_pin: string,
                arg_new_pin: string,
                cancellable?: Gio.Cancellable | null,
            ): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.EnablePin">EnablePin()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_call_enable_pin_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_call_enable_pin_sync() for the synchronous, blocking version of this method.
             * @param arg_pin Argument to pass with the method invocation.
             * @param arg_enabled Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_enable_pin(
                arg_pin: string,
                arg_enabled: boolean,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.EnablePin">EnablePin()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_call_enable_pin_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_call_enable_pin_sync() for the synchronous, blocking version of this method.
             * @param arg_pin Argument to pass with the method invocation.
             * @param arg_enabled Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_enable_pin(
                arg_pin: string,
                arg_enabled: boolean,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.EnablePin">EnablePin()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_call_enable_pin_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_call_enable_pin_sync() for the synchronous, blocking version of this method.
             * @param arg_pin Argument to pass with the method invocation.
             * @param arg_enabled Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_enable_pin(
                arg_pin: string,
                arg_enabled: boolean,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_sim_call_enable_pin().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_sim_call_enable_pin().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_enable_pin_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.EnablePin">EnablePin()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_sim_call_enable_pin() for the asynchronous version of this method.
             * @param arg_pin Argument to pass with the method invocation.
             * @param arg_enabled Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_enable_pin_sync(arg_pin: string, arg_enabled: boolean, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.SendPin">SendPin()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_call_send_pin_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_call_send_pin_sync() for the synchronous, blocking version of this method.
             * @param arg_pin Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_send_pin(arg_pin: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.SendPin">SendPin()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_call_send_pin_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_call_send_pin_sync() for the synchronous, blocking version of this method.
             * @param arg_pin Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_send_pin(
                arg_pin: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.SendPin">SendPin()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_call_send_pin_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_call_send_pin_sync() for the synchronous, blocking version of this method.
             * @param arg_pin Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_send_pin(
                arg_pin: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_sim_call_send_pin().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_sim_call_send_pin().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_send_pin_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.SendPin">SendPin()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_sim_call_send_pin() for the asynchronous version of this method.
             * @param arg_pin Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_send_pin_sync(arg_pin: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.SendPuk">SendPuk()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_call_send_puk_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_call_send_puk_sync() for the synchronous, blocking version of this method.
             * @param arg_puk Argument to pass with the method invocation.
             * @param arg_pin Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_send_puk(arg_puk: string, arg_pin: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.SendPuk">SendPuk()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_call_send_puk_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_call_send_puk_sync() for the synchronous, blocking version of this method.
             * @param arg_puk Argument to pass with the method invocation.
             * @param arg_pin Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_send_puk(
                arg_puk: string,
                arg_pin: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.SendPuk">SendPuk()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_call_send_puk_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_call_send_puk_sync() for the synchronous, blocking version of this method.
             * @param arg_puk Argument to pass with the method invocation.
             * @param arg_pin Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_send_puk(
                arg_puk: string,
                arg_pin: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_sim_call_send_puk().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_sim_call_send_puk().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_send_puk_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.SendPuk">SendPuk()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_sim_call_send_puk() for the asynchronous version of this method.
             * @param arg_puk Argument to pass with the method invocation.
             * @param arg_pin Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_send_puk_sync(arg_puk: string, arg_pin: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.SetPreferredNetworks">SetPreferredNetworks()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_call_set_preferred_networks_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_call_set_preferred_networks_sync() for the synchronous, blocking version of this method.
             * @param arg_preferred_networks Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set_preferred_networks(
                arg_preferred_networks: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.SetPreferredNetworks">SetPreferredNetworks()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_call_set_preferred_networks_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_call_set_preferred_networks_sync() for the synchronous, blocking version of this method.
             * @param arg_preferred_networks Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_preferred_networks(
                arg_preferred_networks: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.SetPreferredNetworks">SetPreferredNetworks()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_call_set_preferred_networks_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_call_set_preferred_networks_sync() for the synchronous, blocking version of this method.
             * @param arg_preferred_networks Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_preferred_networks(
                arg_preferred_networks: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_sim_call_set_preferred_networks().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_sim_call_set_preferred_networks().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_preferred_networks_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.SetPreferredNetworks">SetPreferredNetworks()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_sim_call_set_preferred_networks() for the asynchronous version of this method.
             * @param arg_preferred_networks Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_preferred_networks_sync(
                arg_preferred_networks: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
            ): boolean;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.ChangePin">ChangePin()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_change_pin(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.EnablePin">EnablePin()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_enable_pin(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.SendPin">SendPin()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_send_pin(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.SendPuk">SendPuk()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_send_puk(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.SetPreferredNetworks">SetPreferredNetworks()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_set_preferred_networks(invocation: Gio.DBusMethodInvocation): void;
            vfunc_handle_change_pin(
                invocation: Gio.DBusMethodInvocation,
                arg_old_pin: string,
                arg_new_pin: string,
            ): boolean;
            vfunc_handle_enable_pin(
                invocation: Gio.DBusMethodInvocation,
                arg_pin: string,
                arg_enabled: boolean,
            ): boolean;
            vfunc_handle_send_pin(invocation: Gio.DBusMethodInvocation, arg_pin: string): boolean;
            vfunc_handle_send_puk(invocation: Gio.DBusMethodInvocation, arg_puk: string, arg_pin: string): boolean;
            vfunc_handle_set_preferred_networks(
                invocation: Gio.DBusMethodInvocation,
                arg_preferred_networks: GLib.Variant,
            ): boolean;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a named field from the objects table of associations (see g_object_set_data()).
             * @param key name of the key for that association
             * @returns the data if found,          or %NULL if no such data exists.
             */
            get_data(key: string): any | null;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace SimpleConnectProperties {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {}
        }

        /**
         * The #MMSimpleConnectProperties structure contains private data and should
         * only be accessed using the provided API.
         */
        class SimpleConnectProperties extends GObject.Object {
            static $gtype: GObject.GType<SimpleConnectProperties>;

            // Constructors

            constructor(properties?: Partial<SimpleConnectProperties.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static ['new'](): SimpleConnectProperties;

            // Methods

            /**
             * Checks whether roaming is allowed in the connection.
             * @returns %TRUE if roaming is allowed, %FALSE otherwise.
             */
            get_allow_roaming(): boolean;
            /**
             * Gets the authentication methods allowed in the connection.
             * @returns a bitmask of #MMBearerAllowedAuth values, or %MM_BEARER_ALLOWED_AUTH_UNKNOWN to request the modem-default method.
             */
            get_allowed_auth(): BearerAllowedAuth;
            /**
             * Gets the name of the access point to use when connecting.
             * @returns the access point, or #NULL if not set. Do not free the returned value, it is owned by @self.
             */
            get_apn(): string;
            /**
             * Gets the APN types to use.
             * @returns a mask of #MMBearerApnType values.
             */
            get_apn_type(): BearerApnType;
            /**
             * Sets the IP type to use.
             * @returns a #MMBearerIpFamily.
             */
            get_ip_type(): BearerIpFamily;
            /**
             * Get the multiplex support requested by the user.
             * @returns a #MMBearerMultiplexSupport.
             */
            get_multiplex(): BearerMultiplexSupport;
            /**
             * Gets the number to use when performing the connection.
             * @returns the number, or #NULL if not set. Do not free the returned value, it is owned by @self.
             */
            get_number(): string;
            /**
             * Gets the ID of the network to which register before connecting.
             * @returns the operator ID, or #NULL if not set. Do not free the returned value, it is owned by @self.
             */
            get_operator_id(): string;
            /**
             * Gets the password used to authenticate with the access point.
             * @returns the password, or #NULL if not set. Do not free the returned value, it is owned by @self.
             */
            get_password(): string;
            /**
             * Gets the PIN code to use when unlocking the modem.
             * @returns the PIN, or #NULL if not set. Do not free the returned value, it is owned by @self.
             */
            get_pin(): string;
            /**
             * Gets the profile ID to use.
             * @returns the profile id.
             */
            get_profile_id(): number;
            /**
             * Get the RM protocol requested by the user.
             * @returns a #MMModemCdmaRmProtocol.
             */
            get_rm_protocol(): ModemCdmaRmProtocol;
            /**
             * Gets the username used to authenticate with the access point.
             * @returns the username, or #NULL if not set. Do not free the returned value, it is owned by @self.
             */
            get_user(): string;
            /**
             * Sets the flag to indicate whether roaming is allowed or not in the
             * connection.
             * @param allow_roaming boolean value.
             */
            set_allow_roaming(allow_roaming: boolean): void;
            /**
             * Sets the authentication method to use.
             * @param allowed_auth a bitmask of #MMBearerAllowedAuth values.  %MM_BEARER_ALLOWED_AUTH_UNKNOWN may be given to request the modem-default method.
             */
            set_allowed_auth(allowed_auth: BearerAllowedAuth | null): void;
            /**
             * Sets the name of the access point to use when connecting.
             * @param apn Name of the access point.
             */
            set_apn(apn: string): void;
            /**
             * Sets the APN types to use.
             * @param apn_type a mask of #MMBearerApnType values.
             */
            set_apn_type(apn_type: BearerApnType | null): void;
            /**
             * Sets the IP type to use.
             * @param ip_type a #MMBearerIpFamily.
             */
            set_ip_type(ip_type: BearerIpFamily | null): void;
            /**
             * Sets the multiplex support requested by the user.
             * @param multiplex a #MMBearerMultiplexSupport.
             */
            set_multiplex(multiplex: BearerMultiplexSupport | null): void;
            /**
             * Sets the number to use when performing the connection.
             * @param number the number.
             */
            set_number(number: string): void;
            /**
             * Sets the ID of the network to which register before connecting.
             * @param operator_id operator ID, given as MCC/MNC.
             */
            set_operator_id(operator_id: string): void;
            /**
             * Sets the password used to authenticate with the access point.
             * @param password the password
             */
            set_password(password: string): void;
            /**
             * Sets the PIN code to use when unlocking the modem.
             * @param pin PIN code.
             */
            set_pin(pin: string): void;
            /**
             * Sets the profile ID to use.
             * @param profile_id a profile id.
             */
            set_profile_id(profile_id: number): void;
            /**
             * Sets the RM protocol requested by the user.
             * @param protocol a #MMModemCdmaRmProtocol.
             */
            set_rm_protocol(protocol: ModemCdmaRmProtocol | null): void;
            /**
             * Sets the username used to authenticate with the access point.
             * @param user the username
             */
            set_user(user: string): void;
        }

        namespace SimpleStatus {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                access_technologies: ModemAccessTechnology;
                accessTechnologies: ModemAccessTechnology;
                cdma_cdma1x_registration_state: ModemCdmaRegistrationState;
                cdmaCdma1xRegistrationState: ModemCdmaRegistrationState;
                cdma_evdo_registration_state: ModemCdmaRegistrationState;
                cdmaEvdoRegistrationState: ModemCdmaRegistrationState;
                cdma_nid: number;
                cdmaNid: number;
                cdma_sid: number;
                cdmaSid: number;
                current_bands: GLib.Variant;
                currentBands: GLib.Variant;
                m3gpp_operator_code: string;
                m3gppOperatorCode: string;
                m3gpp_operator_name: string;
                m3gppOperatorName: string;
                m3gpp_registration_state: Modem3gppRegistrationState;
                m3gppRegistrationState: Modem3gppRegistrationState;
                m3gpp_subscription_state: Modem3gppSubscriptionState;
                m3gppSubscriptionState: Modem3gppSubscriptionState;
                signal_quality: GLib.Variant;
                signalQuality: GLib.Variant;
                state: ModemState;
            }
        }

        /**
         * The #MMSimpleStatus structure contains private data and should
         * only be accessed using the provided API.
         */
        class SimpleStatus extends GObject.Object {
            static $gtype: GObject.GType<SimpleStatus>;

            // Properties

            get access_technologies(): ModemAccessTechnology;
            set access_technologies(val: ModemAccessTechnology);
            get accessTechnologies(): ModemAccessTechnology;
            set accessTechnologies(val: ModemAccessTechnology);
            get cdma_cdma1x_registration_state(): ModemCdmaRegistrationState;
            set cdma_cdma1x_registration_state(val: ModemCdmaRegistrationState);
            get cdmaCdma1xRegistrationState(): ModemCdmaRegistrationState;
            set cdmaCdma1xRegistrationState(val: ModemCdmaRegistrationState);
            get cdma_evdo_registration_state(): ModemCdmaRegistrationState;
            set cdma_evdo_registration_state(val: ModemCdmaRegistrationState);
            get cdmaEvdoRegistrationState(): ModemCdmaRegistrationState;
            set cdmaEvdoRegistrationState(val: ModemCdmaRegistrationState);
            get cdma_nid(): number;
            set cdma_nid(val: number);
            get cdmaNid(): number;
            set cdmaNid(val: number);
            get cdma_sid(): number;
            set cdma_sid(val: number);
            get cdmaSid(): number;
            set cdmaSid(val: number);
            get current_bands(): GLib.Variant;
            set current_bands(val: GLib.Variant);
            get currentBands(): GLib.Variant;
            set currentBands(val: GLib.Variant);
            get m3gpp_operator_code(): string;
            set m3gpp_operator_code(val: string);
            get m3gppOperatorCode(): string;
            set m3gppOperatorCode(val: string);
            get m3gpp_operator_name(): string;
            set m3gpp_operator_name(val: string);
            get m3gppOperatorName(): string;
            set m3gppOperatorName(val: string);
            get m3gpp_registration_state(): Modem3gppRegistrationState;
            set m3gpp_registration_state(val: Modem3gppRegistrationState);
            get m3gppRegistrationState(): Modem3gppRegistrationState;
            set m3gppRegistrationState(val: Modem3gppRegistrationState);
            get m3gpp_subscription_state(): Modem3gppSubscriptionState;
            set m3gpp_subscription_state(val: Modem3gppSubscriptionState);
            get m3gppSubscriptionState(): Modem3gppSubscriptionState;
            set m3gppSubscriptionState(val: Modem3gppSubscriptionState);
            get signal_quality(): GLib.Variant;
            set signal_quality(val: GLib.Variant);
            get signalQuality(): GLib.Variant;
            set signalQuality(val: GLib.Variant);
            get state(): ModemState;
            set state(val: ModemState);

            // Constructors

            constructor(properties?: Partial<SimpleStatus.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Methods

            /**
             * Gets the MCC/MNC of the operator of the 3GPP network where the modem is
             * registered.
             * @returns the operator code, or %NULL if unknown. Do not free the returned value, it is owned by @self.
             */
            get_3gpp_operator_code(): string;
            /**
             * Gets the name of the operator of the 3GPP network where the modem is
             * registered.
             * @returns the operator name, or %NULL if unknown. Do not free the returned value, it is owned by @self.
             */
            get_3gpp_operator_name(): string;
            /**
             * Gets the current state of the registration in the 3GPP network.
             * @returns a #MMModem3gppRegistrationState.
             */
            get_3gpp_registration_state(): Modem3gppRegistrationState;
            /**
             * Gets the current subscription status of the account.
             * @returns a #MMModem3gppSubscriptionState.
             */
            get_3gpp_subscription_state(): Modem3gppSubscriptionState;
            /**
             * Gets the currently used access technologies.
             * @returns a bitmask of #MMModemAccessTechnology values.
             */
            get_access_technologies(): ModemAccessTechnology;
            /**
             * Gets the current state of the registration in the CDMA-1x network.
             * @returns a #MMModemCdmaRegistrationState.
             */
            get_cdma_cdma1x_registration_state(): ModemCdmaRegistrationState;
            /**
             * Gets the current state of the registration in the EV-DO network.
             * @returns a #MMModemCdmaRegistrationState.
             */
            get_cdma_evdo_registration_state(): ModemCdmaRegistrationState;
            /**
             * Gets the Network Identification number of the CDMA network.
             * @returns the NID, or %MM_MODEM_CDMA_NID_UNKNOWN if unknown.
             */
            get_cdma_nid(): number;
            /**
             * Gets the System Identification number of the CDMA network.
             * @returns the SID, or %MM_MODEM_CDMA_SID_UNKNOWN if unknown.
             */
            get_cdma_sid(): number;
            /**
             * Gets the currently used frequency bands.
             */
            get_current_bands(): [ModemBand, number];
            /**
             * Gets the signal quality.
             * @returns the signal quality.
             */
            get_signal_quality(): [number, boolean];
            /**
             * Gets the state of the modem.
             * @returns a #MMModemState.
             */
            get_state(): ModemState;
        }

        namespace Sms {
            // Constructor properties interface

            interface ConstructorProps
                extends GdbusSmsProxy.ConstructorProps,
                    Gio.AsyncInitable.ConstructorProps,
                    Gio.DBusInterface.ConstructorProps,
                    Gio.Initable.ConstructorProps,
                    GdbusSms.ConstructorProps {}
        }

        /**
         * The #MMSms structure contains private data and should only be accessed
         * using the provided API.
         */
        class Sms extends GdbusSmsProxy implements Gio.AsyncInitable<Sms>, Gio.DBusInterface, Gio.Initable, GdbusSms {
            static $gtype: GObject.GType<Sms>;

            // Constructors

            constructor(properties?: Partial<Sms.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Methods

            /**
             * Gets the message data.
             * @returns The message data, or %NULL if it doesn't contain any (e.g. contains text instead). The returned value should be freed with g_free().
             */
            dup_data(): Uint8Array;
            /**
             * Gets the time when the first PDU of the SMS message left the SMSC, in
             * <ulink url="http://en.wikipedia.org/wiki/ISO_8601">ISO8601</ulink>
             * format.
             *
             * This field is only applicable if the PDU type is
             * %MM_SMS_PDU_TYPE_STATUS_REPORT.
             * @returns The timestamp, or %NULL if it couldn't be retrieved. The returned value should be freed with g_free().
             */
            dup_discharge_timestamp(): string;
            /**
             * Gets the number to which the message is addressed.
             * @returns The number, or %NULL if it couldn't be retrieved. The returned value should be freed with g_free().
             */
            dup_number(): string;
            /**
             * Gets a copy of the DBus path of the #MMSms object.
             * @returns The DBus path of the #MMSms object. The returned value should be freed with g_free().
             */
            dup_path(): string;
            /**
             * Gets the SMS service center number.
             * @returns The number of the SMSC, or %NULL if it couldn't be retrieved. The returned value should be freed with g_free().
             */
            dup_smsc(): string;
            /**
             * Gets the message text, in UTF-8.
             * @returns The message text, or %NULL if it doesn't contain any (e.g. contains data instead). The returned value should be freed with g_free().
             */
            dup_text(): string;
            /**
             * Gets the time when the first PDU of the SMS message arrived the SMSC, in
             * <ulink url="http://en.wikipedia.org/wiki/ISO_8601">ISO8601</ulink>
             * format.
             *
             * This field is only applicable if the PDU type is %MM_SMS_PDU_TYPE_DELIVER or
             * %MM_SMS_PDU_TYPE_STATUS_REPORT.
             * @returns The timestamp, or %NULL if it couldn't be retrieved. The returned value should be freed with g_free().
             */
            dup_timestamp(): string;
            /**
             * Gets the 3GPP message class of the SMS.
             * @returns the message class, or -1 for invalid/unset class.
             */
            get_class(): number;
            /**
             * Gets the message data.
             * @returns The message data, or %NULL if it doesn't contain any (e.g. contains text instead).
             */
            get_data(): Uint8Array;
            // Conflicted with GObject.Object.get_data
            get_data(...args: never[]): any;
            /**
             * Checks whether delivery report is requested for this SMS.
             * @returns %TRUE if delivery report is requested, %FALSE otherwise.
             */
            get_delivery_report_request(): boolean;
            /**
             * Gets the delivery state of this SMS.
             *
             * This field is only applicable if the PDU type is
             * %MM_SMS_PDU_TYPE_STATUS_REPORT.
             * @returns A #MMSmsDeliveryState specifying the delivery state.
             */
            get_delivery_state(): number;
            /**
             * Gets the time when the first PDU of the SMS message left the SMSC, in
             * <ulink url="http://en.wikipedia.org/wiki/ISO_8601">ISO8601</ulink>
             * format.
             *
             * This field is only applicable if the PDU type is
             * %MM_SMS_PDU_TYPE_STATUS_REPORT.
             *
             * <warning>The returned value is only valid until the property changes so it is
             * only safe to use this function on the thread where `self` was constructed. Use
             * mm_sms_dup_discharge_timestamp() if on another thread.</warning>
             * @returns The timestamp, or %NULL if it couldn't be retrieved.
             */
            get_discharge_timestamp(): string;
            /**
             * Gets the message reference of the last PDU sent/received within this SMS.
             *
             * If the PDU type is %MM_SMS_PDU_TYPE_STATUS_REPORT, this field identifies the
             * message reference of the PDU associated to the status report.
             * @returns The message reference.
             */
            get_message_reference(): number;
            /**
             * Gets the number to which the message is addressed.
             *
             * <warning>The returned value is only valid until the property changes so it is
             * only safe to use this function on the thread where `self` was constructed. Use
             * mm_sms_dup_number() if on another thread.</warning>
             * @returns The number, or %NULL if it couldn't be retrieved.
             */
            get_number(): string;
            /**
             * Gets the DBus path of the #MMSms object.
             * @returns The DBus path of the #MMSms object.
             */
            get_path(): string;
            /**
             * Gets the PDU type on which this SMS is based.
             * @returns A #MMSmsPduType specifying the PDU type.
             */
            get_pdu_type(): SmsPduType;
            /**
             * Gets the 3GPP2 Service Category.
             * @returns a #MMSmsCdmaServiceCategory.
             */
            get_service_category(): SmsCdmaServiceCategory;
            /**
             * Gets the SMS service center number.
             *
             * <warning>The returned value is only valid until the property changes so it is
             * only safe to use this function on the thread where `self` was constructed. Use
             * mm_sms_dup_smsc() if on another thread.</warning>
             * @returns The number of the SMSC, or %NULL if it couldn't be retrieved.
             */
            get_smsc(): string;
            /**
             * Gets the state of this SMS.
             * @returns A #MMSmsState specifying the state.
             */
            get_state(): SmsState;
            /**
             * Gets the storage in which this SMS is kept.
             * @returns A #MMSmsStorage specifying the storage.
             */
            get_storage(): SmsStorage;
            /**
             * Gets the 3GPP2 Teleservice ID.
             * @returns a #MMSmsCdmaTeleserviceId.
             */
            get_teleservice_id(): SmsCdmaTeleserviceId;
            /**
             * Gets the message text, in UTF-8.
             *
             * <warning>The returned value is only valid until the property changes so it is
             * only safe to use this function on the thread where `self` was constructed. Use
             * mm_sms_dup_text() if on another thread.</warning>
             * @returns The message text, or %NULL if it doesn't contain any (e.g. contains data instead).
             */
            get_text(): string;
            /**
             * Gets the time when the first PDU of the SMS message arrived the SMSC, in
             * <ulink url="http://en.wikipedia.org/wiki/ISO_8601">ISO8601</ulink>
             * format.
             *
             * This field is only applicable if the PDU type is %MM_SMS_PDU_TYPE_DELIVER or
             * %MM_SMS_PDU_TYPE_STATUS_REPORT.
             *
             * <warning>The returned value is only valid until the property changes so it is
             * only safe to use this function on the thread where `self` was constructed. Use
             * mm_sms_dup_timestamp() if on another thread.</warning>
             * @returns The timestamp, or %NULL if it couldn't be retrieved.
             */
            get_timestamp(): string;
            /**
             * Gets the length of the validity period, in minutes.
             *
             * Only applicable if the type of validity is #MM_SMS_VALIDITY_TYPE_RELATIVE.
             * @returns the length of the validity period, or 0 if unknown.
             */
            get_validity_relative(): number;
            /**
             * Gets the type of validity information in the SMS.
             * @returns the validity type or #MM_SMS_VALIDITY_TYPE_UNKNOWN.
             */
            get_validity_type(): SmsValidityType;
            /**
             * Asynchronously requests to queue the message for delivery.
             *
             * SMS objects can only be sent once.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_sms_send_finish() to get the result of the operation.
             *
             * See mm_sms_send_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            send(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously requests to queue the message for delivery.
             *
             * SMS objects can only be sent once.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_sms_send_finish() to get the result of the operation.
             *
             * See mm_sms_send_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            send(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously requests to queue the message for delivery.
             *
             * SMS objects can only be sent once.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_sms_send_finish() to get the result of the operation.
             *
             * See mm_sms_send_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            send(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_sms_send().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_sms_send().
             * @returns %TRUE if the operation succeeded, %FALSE if @error is set.
             */
            send_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously requests to queue the message for delivery.
             *
             * SMS objects can only be sent once.
             *
             * The calling thread is blocked until a reply is received. See mm_sms_send()
             * for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the operation succeeded, %FALSE if @error is set.
             */
            send_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronoulsy requests to store the message in the device if not already done.
             *
             * SMS objects can only be stored once.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_sms_store_finish() to get the result of the operation.
             *
             * See mm_sms_store_sync() for the synchronous, blocking version of this method.
             * @param storage A #MMSmsStorage specifying where to store the SMS, or  %MM_SMS_STORAGE_UNKNOWN to use the default.
             * @param cancellable A #GCancellable or %NULL.
             */
            store(storage: SmsStorage | null, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronoulsy requests to store the message in the device if not already done.
             *
             * SMS objects can only be stored once.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_sms_store_finish() to get the result of the operation.
             *
             * See mm_sms_store_sync() for the synchronous, blocking version of this method.
             * @param storage A #MMSmsStorage specifying where to store the SMS, or  %MM_SMS_STORAGE_UNKNOWN to use the default.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            store(
                storage: SmsStorage | null,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronoulsy requests to store the message in the device if not already done.
             *
             * SMS objects can only be stored once.
             *
             * When the operation is finished, `callback` will be invoked in the
             * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
             * of the thread you are calling this method from. You can then call
             * mm_sms_store_finish() to get the result of the operation.
             *
             * See mm_sms_store_sync() for the synchronous, blocking version of this method.
             * @param storage A #MMSmsStorage specifying where to store the SMS, or  %MM_SMS_STORAGE_UNKNOWN to use the default.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or  %NULL.
             */
            store(
                storage: SmsStorage | null,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_sms_store().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to  mm_sms_store().
             * @returns %TRUE if the operation succeeded, %FALSE if @error is set.
             */
            store_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronoulsy requests to store the message in the device if not already
             * done.
             *
             * SMS objects can only be stored once.
             *
             * The calling thread is blocked until a reply is received. See mm_sms_store()
             * for the asynchronous version of this method.
             * @param storage A #MMSmsStorage specifying where to store the SMS, or  %MM_SMS_STORAGE_UNKNOWN to use the default.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the operation succeeded, %FALSE if @error is set.
             */
            store_sync(storage: SmsStorage | null, cancellable?: Gio.Cancellable | null): boolean;

            // Inherited properties
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.Class">"Class"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get class(): number;
            set class(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.Data">"Data"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get data(): GLib.Variant;
            set data(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.DeliveryReportRequest">"DeliveryReportRequest"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get delivery_report_request(): boolean;
            set delivery_report_request(val: boolean);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.DeliveryReportRequest">"DeliveryReportRequest"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get deliveryReportRequest(): boolean;
            set deliveryReportRequest(val: boolean);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.DeliveryState">"DeliveryState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get delivery_state(): number;
            set delivery_state(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.DeliveryState">"DeliveryState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get deliveryState(): number;
            set deliveryState(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.DischargeTimestamp">"DischargeTimestamp"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get discharge_timestamp(): string;
            set discharge_timestamp(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.DischargeTimestamp">"DischargeTimestamp"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get dischargeTimestamp(): string;
            set dischargeTimestamp(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.MessageReference">"MessageReference"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get message_reference(): number;
            set message_reference(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.MessageReference">"MessageReference"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get messageReference(): number;
            set messageReference(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.Number">"Number"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get number(): string;
            set number(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.PduType">"PduType"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get pdu_type(): number;
            set pdu_type(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.PduType">"PduType"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get pduType(): number;
            set pduType(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.ServiceCategory">"ServiceCategory"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get service_category(): number;
            set service_category(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.ServiceCategory">"ServiceCategory"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get serviceCategory(): number;
            set serviceCategory(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.SMSC">"SMSC"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get smsc(): string;
            set smsc(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.State">"State"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get state(): number;
            set state(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.Storage">"Storage"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get storage(): number;
            set storage(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.TeleserviceId">"TeleserviceId"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get teleservice_id(): number;
            set teleservice_id(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.TeleserviceId">"TeleserviceId"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get teleserviceId(): number;
            set teleserviceId(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.Text">"Text"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get text(): string;
            set text(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.Timestamp">"Timestamp"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get timestamp(): string;
            set timestamp(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.Validity">"Validity"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get validity(): GLib.Variant;
            set validity(val: GLib.Variant);

            // Inherited methods
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             */
            init_async(io_priority: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             * @returns %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present.
             */
            init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Finishes the async construction for the various g_async_initable_new
             * calls, returning the created object or %NULL on error.
             * @param res the #GAsyncResult from the callback
             * @returns a newly created #GObject,      or %NULL on error. Free with g_object_unref().
             */
            new_finish(res: Gio.AsyncResult): Sms;
            // Conflicted with ModemManager.GdbusSmsProxy.new_finish
            new_finish(...args: never[]): any;
            /**
             * Starts asynchronous initialization of the object implementing the
             * interface. This must be done before any real use of the object after
             * initial construction. If the object also implements #GInitable you can
             * optionally call g_initable_init() instead.
             *
             * This method is intended for language bindings. If writing in C,
             * g_async_initable_new_async() should typically be used instead.
             *
             * When the initialization is finished, `callback` will be called. You can
             * then call g_async_initable_init_finish() to get the result of the
             * initialization.
             *
             * Implementations may also support cancellation. If `cancellable` is not
             * %NULL, then initialization can be cancelled by triggering the cancellable
             * object from another thread. If the operation was cancelled, the error
             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
             * the object doesn't support cancellable initialization, the error
             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
             *
             * As with #GInitable, if the object is not initialized, or initialization
             * returns with an error, then all operations on the object except
             * g_object_ref() and g_object_unref() are considered to be invalid, and
             * have undefined behaviour. They will often fail with g_critical() or
             * g_warning(), but this must not be relied on.
             *
             * Callers should not assume that a class which implements #GAsyncInitable can
             * be initialized multiple times; for more information, see g_initable_init().
             * If a class explicitly supports being initialized multiple times,
             * implementation requires yielding all subsequent calls to init_async() on the
             * results of the first call.
             *
             * For classes that also support the #GInitable interface, the default
             * implementation of this method will run the g_initable_init() function
             * in a thread, so if you want to support asynchronous initialization via
             * threads, just implement the #GAsyncInitable interface without overriding
             * any interface methods.
             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
             * @param cancellable optional #GCancellable object, %NULL to ignore.
             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
             */
            vfunc_init_async(
                io_priority: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Finishes asynchronous initialization and returns the result.
             * See g_async_initable_init_async().
             * @param res a #GAsyncResult.
             */
            vfunc_init_finish(res: Gio.AsyncResult): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sms.Send">Send()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sms_call_send_finish() to get the result of the operation.
             *
             * See mm_gdbus_sms_call_send_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_send(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sms.Send">Send()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sms_call_send_finish() to get the result of the operation.
             *
             * See mm_gdbus_sms_call_send_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_send(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sms.Send">Send()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sms_call_send_finish() to get the result of the operation.
             *
             * See mm_gdbus_sms_call_send_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_send(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_sms_call_send().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_sms_call_send().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_send_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sms.Send">Send()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_sms_call_send() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_send_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sms.Store">Store()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sms_call_store_finish() to get the result of the operation.
             *
             * See mm_gdbus_sms_call_store_sync() for the synchronous, blocking version of this method.
             * @param arg_storage Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_store(arg_storage: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sms.Store">Store()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sms_call_store_finish() to get the result of the operation.
             *
             * See mm_gdbus_sms_call_store_sync() for the synchronous, blocking version of this method.
             * @param arg_storage Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_store(
                arg_storage: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sms.Store">Store()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sms_call_store_finish() to get the result of the operation.
             *
             * See mm_gdbus_sms_call_store_sync() for the synchronous, blocking version of this method.
             * @param arg_storage Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_store(
                arg_storage: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_sms_call_store().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_sms_call_store().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_store_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sms.Store">Store()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_sms_call_store() for the asynchronous version of this method.
             * @param arg_storage Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_store_sync(arg_storage: number, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sms.Send">Send()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_send(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sms.Store">Store()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_store(invocation: Gio.DBusMethodInvocation): void;
            vfunc_handle_send(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_store(invocation: Gio.DBusMethodInvocation, arg_storage: number): boolean;
            /**
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target`.
             *
             * Whenever the `source_property` is changed the `target_property` is
             * updated using the same value. For instance:
             *
             *
             * ```c
             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
             * ```
             *
             *
             * Will result in the "sensitive" property of the widget #GObject instance to be
             * updated with the same value of the "active" property of the action #GObject
             * instance.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well.
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. To remove the binding without affecting the
             * `source` and the `target` you can just call g_object_unref() on the returned
             * #GBinding instance.
             *
             * Removing the binding by calling g_object_unref() on it must only be done if
             * the binding, `source` and `target` are only used from a single thread and it
             * is clear that both `source` and `target` outlive the binding. Especially it
             * is not safe to rely on this if the binding, `source` or `target` can be
             * finalized from different threads. Keep another reference to the binding and
             * use g_binding_unbind() instead to be on the safe side.
             *
             * A #GObject can have multiple bindings.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
            ): GObject.Binding;
            /**
             * Complete version of g_object_bind_property().
             *
             * Creates a binding between `source_property` on `source` and `target_property`
             * on `target,` allowing you to set the transformation functions to be used by
             * the binding.
             *
             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
             * if `target_property` on `target` changes then the `source_property` on `source`
             * will be updated as well. The `transform_from` function is only used in case
             * of bidirectional bindings, otherwise it will be ignored
             *
             * The binding will automatically be removed when either the `source` or the
             * `target` instances are finalized. This will release the reference that is
             * being held on the #GBinding instance; if you want to hold on to the
             * #GBinding instance, you will need to hold a reference to it.
             *
             * To remove the binding, call g_binding_unbind().
             *
             * A #GObject can have multiple bindings.
             *
             * The same `user_data` parameter will be used for both `transform_to`
             * and `transform_from` transformation functions; the `notify` function will
             * be called once, when the binding is removed. If you need different data
             * for each transformation function, please use
             * g_object_bind_property_with_closures() instead.
             * @param source_property the property on @source to bind
             * @param target the target #GObject
             * @param target_property the property on @target to bind
             * @param flags flags to pass to #GBinding
             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
             */
            bind_property_full(
                source_property: string,
                target: GObject.Object,
                target_property: string,
                flags: GObject.BindingFlags | null,
                transform_to?: GObject.BindingTransformFunc | null,
                transform_from?: GObject.BindingTransformFunc | null,
                notify?: GLib.DestroyNotify | null,
            ): GObject.Binding;
            // Conflicted with GObject.Object.bind_property_full
            bind_property_full(...args: never[]): any;
            /**
             * This function is intended for #GObject implementations to re-enforce
             * a [floating][floating-ref] object reference. Doing this is seldom
             * required: all #GInitiallyUnowneds are created with a floating reference
             * which usually just needs to be sunken by calling g_object_ref_sink().
             */
            force_floating(): void;
            /**
             * Increases the freeze count on `object`. If the freeze count is
             * non-zero, the emission of "notify" signals on `object` is
             * stopped. The signals are queued until the freeze count is decreased
             * to zero. Duplicate notifications are squashed so that at most one
             * #GObject::notify signal is emitted for each property modified while the
             * object is frozen.
             *
             * This is necessary for accessors that modify multiple properties to prevent
             * premature notification while the object is still being modified.
             */
            freeze_notify(): void;
            /**
             * Gets a property of an object.
             *
             * The value can be:
             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
             * - a GObject.Value initialized with the expected type of the property
             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
             *
             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
             *
             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
             * @param property_name The name of the property to get
             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
             */
            get_property(property_name: string, value: GObject.Value | any): any;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            get_qdata(quark: GLib.Quark): any | null;
            /**
             * Gets `n_properties` properties for an `object`.
             * Obtained properties will be set to `values`. All properties must be valid.
             * Warnings will be emitted and undefined behaviour may result if invalid
             * properties are passed in.
             * @param names the names of each property to get
             * @param values the values of each property to get
             */
            getv(names: string[], values: (GObject.Value | any)[]): void;
            /**
             * Checks whether `object` has a [floating][floating-ref] reference.
             * @returns %TRUE if @object has a floating reference
             */
            is_floating(): boolean;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param property_name the name of a property installed on the class of @object.
             */
            notify(property_name: string): void;
            /**
             * Emits a "notify" signal for the property specified by `pspec` on `object`.
             *
             * This function omits the property name lookup, hence it is faster than
             * g_object_notify().
             *
             * One way to avoid using g_object_notify() from within the
             * class that registered the properties, and using g_object_notify_by_pspec()
             * instead, is to store the GParamSpec used with
             * g_object_class_install_property() inside a static array, e.g.:
             *
             *
             * ```c
             *   typedef enum
             *   {
             *     PROP_FOO = 1,
             *     PROP_LAST
             *   } MyObjectProperty;
             *
             *   static GParamSpec *properties[PROP_LAST];
             *
             *   static void
             *   my_object_class_init (MyObjectClass *klass)
             *   {
             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
             *                                              0, 100,
             *                                              50,
             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
             *     g_object_class_install_property (gobject_class,
             *                                      PROP_FOO,
             *                                      properties[PROP_FOO]);
             *   }
             * ```
             *
             *
             * and then notify a change on the "foo" property with:
             *
             *
             * ```c
             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
             * ```
             *
             * @param pspec the #GParamSpec of a property installed on the class of @object.
             */
            notify_by_pspec(pspec: GObject.ParamSpec): void;
            /**
             * Increases the reference count of `object`.
             *
             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
             * of `object` will be propagated to the return type (using the GCC typeof()
             * extension), so any casting the caller needs to do on the return type must be
             * explicit.
             * @returns the same @object
             */
            ref(): GObject.Object;
            /**
             * Increase the reference count of `object,` and possibly remove the
             * [floating][floating-ref] reference, if `object` has a floating reference.
             *
             * In other words, if the object is floating, then this call "assumes
             * ownership" of the floating reference, converting it to a normal
             * reference by clearing the floating flag while leaving the reference
             * count unchanged.  If the object is not floating, then this call
             * adds a new normal reference increasing the reference count by one.
             *
             * Since GLib 2.56, the type of `object` will be propagated to the return type
             * under the same conditions as for g_object_ref().
             * @returns @object
             */
            ref_sink(): GObject.Object;
            /**
             * Releases all references to other objects. This can be used to break
             * reference cycles.
             *
             * This function should only be called from object system implementations.
             */
            run_dispose(): void;
            /**
             * Each object carries around a table of associations from
             * strings to pointers.  This function lets you set an association.
             *
             * If the object already had an association with that name,
             * the old association will be destroyed.
             *
             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
             * This means a copy of `key` is kept permanently (even after `object` has been
             * finalized) — so it is recommended to only use a small, bounded set of values
             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
             * @param key name of the key
             * @param data data to associate with that key
             */
            set_data(key: string, data?: any | null): void;
            /**
             * Sets a property on an object.
             * @param property_name The name of the property to set
             * @param value The value to set the property to
             */
            set_property(property_name: string, value: GObject.Value | any): void;
            /**
             * Remove a specified datum from the object's data associations,
             * without invoking the association's destroy handler.
             * @param key name of the key
             * @returns the data if found, or %NULL          if no such data exists.
             */
            steal_data(key: string): any | null;
            /**
             * This function gets back user data pointers stored via
             * g_object_set_qdata() and removes the `data` from object
             * without invoking its destroy() function (if any was
             * set).
             * Usually, calling this function is only required to update
             * user data pointers with a destroy notifier, for example:
             *
             * ```c
             * void
             * object_add_to_user_list (GObject     *object,
             *                          const gchar *new_string)
             * {
             *   // the quark, naming the object data
             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
             *   // retrieve the old string list
             *   GList *list = g_object_steal_qdata (object, quark_string_list);
             *
             *   // prepend new string
             *   list = g_list_prepend (list, g_strdup (new_string));
             *   // this changed 'list', so we need to set it again
             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
             * }
             * static void
             * free_string_list (gpointer data)
             * {
             *   GList *node, *list = data;
             *
             *   for (node = list; node; node = node->next)
             *     g_free (node->data);
             *   g_list_free (list);
             * }
             * ```
             *
             * Using g_object_get_qdata() in the above example, instead of
             * g_object_steal_qdata() would have left the destroy function set,
             * and thus the partial string list would have been freed upon
             * g_object_set_qdata_full().
             * @param quark A #GQuark, naming the user data pointer
             * @returns The user data pointer set, or %NULL
             */
            steal_qdata(quark: GLib.Quark): any | null;
            /**
             * Reverts the effect of a previous call to
             * g_object_freeze_notify(). The freeze count is decreased on `object`
             * and when it reaches zero, queued "notify" signals are emitted.
             *
             * Duplicate notifications for each property are squashed so that at most one
             * #GObject::notify signal is emitted for each property, in the reverse order
             * in which they have been queued.
             *
             * It is an error to call this function when the freeze count is zero.
             */
            thaw_notify(): void;
            /**
             * Decreases the reference count of `object`. When its reference count
             * drops to 0, the object is finalized (i.e. its memory is freed).
             *
             * If the pointer to the #GObject may be reused in future (for example, if it is
             * an instance variable of another object), it is recommended to clear the
             * pointer to %NULL rather than retain a dangling pointer to a potentially
             * invalid #GObject instance. Use g_clear_object() for this.
             */
            unref(): void;
            /**
             * This function essentially limits the life time of the `closure` to
             * the life time of the object. That is, when the object is finalized,
             * the `closure` is invalidated by calling g_closure_invalidate() on
             * it, in order to prevent invocations of the closure with a finalized
             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
             * added as marshal guards to the `closure,` to ensure that an extra
             * reference count is held on `object` during invocation of the
             * `closure`.  Usually, this function will be called on closures that
             * use this `object` as closure data.
             * @param closure #GClosure to watch
             */
            watch_closure(closure: GObject.Closure): void;
            /**
             * the `constructed` function is called by g_object_new() as the
             *  final step of the object creation process.  At the point of the call, all
             *  construction properties have been set on the object.  The purpose of this
             *  call is to allow for object initialisation steps that can only be performed
             *  after construction properties have been set.  `constructed` implementors
             *  should chain up to the `constructed` call of their parent class to allow it
             *  to complete its initialisation.
             */
            vfunc_constructed(): void;
            /**
             * emits property change notification for a bunch
             *  of properties. Overriding `dispatch_properties_changed` should be rarely
             *  needed.
             * @param n_pspecs
             * @param pspecs
             */
            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
            /**
             * the `dispose` function is supposed to drop all references to other
             *  objects, but keep the instance otherwise intact, so that client method
             *  invocations still work. It may be run multiple times (due to reference
             *  loops). Before returning, `dispose` should chain up to the `dispose` method
             *  of the parent class.
             */
            vfunc_dispose(): void;
            /**
             * instance finalization function, should finish the finalization of
             *  the instance begun in `dispose` and chain up to the `finalize` method of the
             *  parent class.
             */
            vfunc_finalize(): void;
            /**
             * the generic getter for all properties of this type. Should be
             *  overridden for every type with properties.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Emits a "notify" signal for the property `property_name` on `object`.
             *
             * When possible, eg. when signaling a property change from within the class
             * that registered the property, you should use g_object_notify_by_pspec()
             * instead.
             *
             * Note that emission of the notify signal may be blocked with
             * g_object_freeze_notify(). In this case, the signal emissions are queued
             * and will be emitted (in reverse order) when g_object_thaw_notify() is
             * called.
             * @param pspec
             */
            vfunc_notify(pspec: GObject.ParamSpec): void;
            /**
             * the generic setter for all properties of this type. Should be
             *  overridden for every type with properties. If implementations of
             *  `set_property` don't emit property change notification explicitly, this will
             *  be done implicitly by the type system. However, if the notify signal is
             *  emitted explicitly, the type system will not emit it a second time.
             * @param property_id
             * @param value
             * @param pspec
             */
            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
            /**
             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
             * @param id Handler ID of the handler to be disconnected
             */
            disconnect(id: number): void;
            /**
             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
             * @param properties Object containing the properties to set
             */
            set(properties: { [key: string]: any }): void;
            /**
             * Blocks a handler of an instance so it will not be called during any signal emissions
             * @param id Handler ID of the handler to be blocked
             */
            block_signal_handler(id: number): void;
            /**
             * Unblocks a handler so it will be called again during any signal emissions
             * @param id Handler ID of the handler to be unblocked
             */
            unblock_signal_handler(id: number): void;
            /**
             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
             * @param detailedName Name of the signal to stop emission of
             */
            stop_emission_by_name(detailedName: string): void;
        }

        namespace SmsProperties {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {}
        }

        /**
         * The #MMSmsProperties structure contains private data and should only be
         * accessed using the provided API.
         */
        class SmsProperties extends GObject.Object {
            static $gtype: GObject.GType<SmsProperties>;

            // Constructors

            constructor(properties?: Partial<SmsProperties.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            static ['new'](): SmsProperties;

            // Methods

            /**
             * Gets the 3GPP message class of the SMS.
             * @returns the message class, or -1 for invalid/unset class.
             */
            get_class(): number;
            /**
             * Gets the message data.
             * @returns The message data, or %NULL if it doesn't contain any (e.g. contains text instead).
             */
            get_data(): [number, number];
            // Conflicted with GObject.Object.get_data
            get_data(...args: never[]): any;
            /**
             * Gets the message data.
             * @returns A #GByteArray with the message data, or %NULL if it doesn't contain any (e.g. contains text instead). The returned value should be freed with g_byte_array_unref().
             */
            get_data_bytearray(): Uint8Array;
            /**
             * Checks whether delivery report is requested for the SMS.
             * @returns %TRUE if delivery report is requested, %FALSE otherwise.
             */
            get_delivery_report_request(): boolean;
            /**
             * Gets the number to which the message is addressed.
             * @returns The number, or %NULL if it couldn't be retrieved. Do not free the returned value, it is owned by @self.
             */
            get_number(): string;
            /**
             * Gets the CDMA message service category of the SMS.
             * @returns the CDMA service category.
             */
            get_service_category(): SmsCdmaServiceCategory;
            /**
             * Gets the SMS service center number.
             * @returns The number of the SMSC, or %NULL if it couldn't be retrieved. Do not free the returned value, it is owned by @self.
             */
            get_smsc(): string;
            /**
             * Gets the CDMA teleservice ID of the SMS.
             * @returns the CDMA teleservice ID.
             */
            get_teleservice_id(): SmsCdmaTeleserviceId;
            /**
             * Gets the message text, in UTF-8.
             * @returns The message text, or %NULL if it doesn't contain any (e.g. contains data instead). Do not free the returned value, it is owned by @self.
             */
            get_text(): string;
            /**
             * Gets the relative validity time of the SMS.
             * @returns the validity time or 0 if unknown.
             */
            get_validity_relative(): number;
            /**
             * Gets the relative validity type the SMS.
             * @returns a #MMSmsValidityType.
             */
            get_validity_type(): SmsValidityType;
            /**
             * Gets the message data.
             * @returns A #GByteArray with the message data, or %NULL if it doesn't contain any (e.g. contains text instead). Do not free the returned value, it is owned by @self.
             */
            peek_data_bytearray(): Uint8Array;
            /**
             * Sets the 3GPP message class of the SMS.
             * @param message_class The message class (0..3), or -1 for invalid/unset class.
             */
            set_class(message_class: number): void;
            /**
             * Sets the message data.
             * @param data The data to set.
             * @param data_length Length of @data.
             */
            set_data(data: number, data_length: number): void;
            // Conflicted with GObject.Object.set_data
            set_data(...args: never[]): any;
            /**
             * Sets the message data.
             * @param data A #GByteArray with the data to set. This method takes a new reference  of @data.
             */
            set_data_bytearray(data: Uint8Array | string): void;
            /**
             * Sets whether delivery report is requested for the SMS.
             * @param request %TRUE if delivery report is requested, %FALSE otherwise.
             */
            set_delivery_report_request(request: boolean): void;
            /**
             * Sets the number to which the message is addressed.
             * @param number The number.
             */
            set_number(number: string): void;
            /**
             * Sets the CDMA service category of the SMS.
             * @param service_category The CDMA service category.
             */
            set_service_category(service_category: SmsCdmaServiceCategory | null): void;
            /**
             * Sets the SMS service center number.
             * @param smsc The SMSC number.
             */
            set_smsc(smsc: string): void;
            /**
             * Sets the CDMA teleservice ID of the SMS.
             * @param teleservice_id The CDMA teleservice ID.
             */
            set_teleservice_id(teleservice_id: SmsCdmaTeleserviceId | null): void;
            /**
             * Sets the message text.
             * @param text The text to set, in UTF-8.
             */
            set_text(text: string): void;
            /**
             * Sets the relative validity time of the SMS.
             * @param validity The validity of %MM_SMS_VALIDITY_TYPE_RELATIVE type.
             */
            set_validity_relative(validity: number): void;
        }

        namespace UnlockRetries {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {}
        }

        /**
         * The #MMUnlockRetries structure contains private data and should only be accessed
         * using the provided API.
         */
        class UnlockRetries extends GObject.Object {
            static $gtype: GObject.GType<UnlockRetries>;

            // Constructors

            constructor(properties?: Partial<UnlockRetries.ConstructorProps>, ...args: any[]);

            _init(...args: any[]): void;

            // Methods

            /**
             * Executes `callback` for each lock information found in `self`.
             * @param callback callback to call for each available lock.
             */
            foreach(callback: UnlockRetriesForeachCb): void;
            /**
             * Gets the unlock retries for the given `lock`.
             * @param lock a #MMModemLock.
             * @returns the unlock retries or %MM_UNLOCK_RETRIES_UNKNOWN if unknown.
             */
            get(lock: ModemLock | null): number;
        }

        type __3gppProfileClass = typeof __3gppProfile;
        abstract class __3gppProfilePrivate {
            static $gtype: GObject.GType<__3gppProfilePrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type BearerClass = typeof Bearer;
        type BearerIpConfigClass = typeof BearerIpConfig;
        abstract class BearerIpConfigPrivate {
            static $gtype: GObject.GType<BearerIpConfigPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        abstract class BearerPrivate {
            static $gtype: GObject.GType<BearerPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type BearerPropertiesClass = typeof BearerProperties;
        abstract class BearerPropertiesPrivate {
            static $gtype: GObject.GType<BearerPropertiesPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type BearerStatsClass = typeof BearerStats;
        abstract class BearerStatsPrivate {
            static $gtype: GObject.GType<BearerStatsPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type CallAudioFormatClass = typeof CallAudioFormat;
        abstract class CallAudioFormatPrivate {
            static $gtype: GObject.GType<CallAudioFormatPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type CallClass = typeof Call;
        abstract class CallPrivate {
            static $gtype: GObject.GType<CallPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type CallPropertiesClass = typeof CallProperties;
        abstract class CallPropertiesPrivate {
            static $gtype: GObject.GType<CallPropertiesPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type CdmaManualActivationPropertiesClass = typeof CdmaManualActivationProperties;
        abstract class CdmaManualActivationPropertiesPrivate {
            static $gtype: GObject.GType<CdmaManualActivationPropertiesPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type CellInfoCdmaClass = typeof CellInfoCdma;
        abstract class CellInfoCdmaPrivate {
            static $gtype: GObject.GType<CellInfoCdmaPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type CellInfoClass = typeof CellInfo;
        type CellInfoGsmClass = typeof CellInfoGsm;
        abstract class CellInfoGsmPrivate {
            static $gtype: GObject.GType<CellInfoGsmPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type CellInfoLteClass = typeof CellInfoLte;
        abstract class CellInfoLtePrivate {
            static $gtype: GObject.GType<CellInfoLtePrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type CellInfoNr5gClass = typeof CellInfoNr5g;
        abstract class CellInfoNr5gPrivate {
            static $gtype: GObject.GType<CellInfoNr5gPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        abstract class CellInfoPrivate {
            static $gtype: GObject.GType<CellInfoPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type CellInfoTdscdmaClass = typeof CellInfoTdscdma;
        abstract class CellInfoTdscdmaPrivate {
            static $gtype: GObject.GType<CellInfoTdscdmaPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type CellInfoUmtsClass = typeof CellInfoUmts;
        abstract class CellInfoUmtsPrivate {
            static $gtype: GObject.GType<CellInfoUmtsPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type FirmwarePropertiesClass = typeof FirmwareProperties;
        abstract class FirmwarePropertiesPrivate {
            static $gtype: GObject.GType<FirmwarePropertiesPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type FirmwareUpdateSettingsClass = typeof FirmwareUpdateSettings;
        abstract class FirmwareUpdateSettingsPrivate {
            static $gtype: GObject.GType<FirmwareUpdateSettingsPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type GdbusBearerIface = typeof GdbusBearer;
        type GdbusBearerProxyClass = typeof GdbusBearerProxy;
        abstract class GdbusBearerProxyPrivate {
            static $gtype: GObject.GType<GdbusBearerProxyPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type GdbusBearerSkeletonClass = typeof GdbusBearerSkeleton;
        abstract class GdbusBearerSkeletonPrivate {
            static $gtype: GObject.GType<GdbusBearerSkeletonPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type GdbusCallIface = typeof GdbusCall;
        type GdbusCallProxyClass = typeof GdbusCallProxy;
        abstract class GdbusCallProxyPrivate {
            static $gtype: GObject.GType<GdbusCallProxyPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type GdbusCallSkeletonClass = typeof GdbusCallSkeleton;
        abstract class GdbusCallSkeletonPrivate {
            static $gtype: GObject.GType<GdbusCallSkeletonPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type GdbusModem3gppIface = typeof GdbusModem3gpp;
        type GdbusModem3gppProfileManagerIface = typeof GdbusModem3gppProfileManager;
        type GdbusModem3gppProfileManagerProxyClass = typeof GdbusModem3gppProfileManagerProxy;
        abstract class GdbusModem3gppProfileManagerProxyPrivate {
            static $gtype: GObject.GType<GdbusModem3gppProfileManagerProxyPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type GdbusModem3gppProfileManagerSkeletonClass = typeof GdbusModem3gppProfileManagerSkeleton;
        abstract class GdbusModem3gppProfileManagerSkeletonPrivate {
            static $gtype: GObject.GType<GdbusModem3gppProfileManagerSkeletonPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type GdbusModem3gppProxyClass = typeof GdbusModem3gppProxy;
        abstract class GdbusModem3gppProxyPrivate {
            static $gtype: GObject.GType<GdbusModem3gppProxyPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type GdbusModem3gppSkeletonClass = typeof GdbusModem3gppSkeleton;
        abstract class GdbusModem3gppSkeletonPrivate {
            static $gtype: GObject.GType<GdbusModem3gppSkeletonPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type GdbusModem3gppUssdIface = typeof GdbusModem3gppUssd;
        type GdbusModem3gppUssdProxyClass = typeof GdbusModem3gppUssdProxy;
        abstract class GdbusModem3gppUssdProxyPrivate {
            static $gtype: GObject.GType<GdbusModem3gppUssdProxyPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type GdbusModem3gppUssdSkeletonClass = typeof GdbusModem3gppUssdSkeleton;
        abstract class GdbusModem3gppUssdSkeletonPrivate {
            static $gtype: GObject.GType<GdbusModem3gppUssdSkeletonPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type GdbusModemCdmaIface = typeof GdbusModemCdma;
        type GdbusModemCdmaProxyClass = typeof GdbusModemCdmaProxy;
        abstract class GdbusModemCdmaProxyPrivate {
            static $gtype: GObject.GType<GdbusModemCdmaProxyPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type GdbusModemCdmaSkeletonClass = typeof GdbusModemCdmaSkeleton;
        abstract class GdbusModemCdmaSkeletonPrivate {
            static $gtype: GObject.GType<GdbusModemCdmaSkeletonPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type GdbusModemFirmwareIface = typeof GdbusModemFirmware;
        type GdbusModemFirmwareProxyClass = typeof GdbusModemFirmwareProxy;
        abstract class GdbusModemFirmwareProxyPrivate {
            static $gtype: GObject.GType<GdbusModemFirmwareProxyPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type GdbusModemFirmwareSkeletonClass = typeof GdbusModemFirmwareSkeleton;
        abstract class GdbusModemFirmwareSkeletonPrivate {
            static $gtype: GObject.GType<GdbusModemFirmwareSkeletonPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type GdbusModemIface = typeof GdbusModem;
        type GdbusModemLocationIface = typeof GdbusModemLocation;
        type GdbusModemLocationProxyClass = typeof GdbusModemLocationProxy;
        abstract class GdbusModemLocationProxyPrivate {
            static $gtype: GObject.GType<GdbusModemLocationProxyPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type GdbusModemLocationSkeletonClass = typeof GdbusModemLocationSkeleton;
        abstract class GdbusModemLocationSkeletonPrivate {
            static $gtype: GObject.GType<GdbusModemLocationSkeletonPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type GdbusModemMessagingIface = typeof GdbusModemMessaging;
        type GdbusModemMessagingProxyClass = typeof GdbusModemMessagingProxy;
        abstract class GdbusModemMessagingProxyPrivate {
            static $gtype: GObject.GType<GdbusModemMessagingProxyPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type GdbusModemMessagingSkeletonClass = typeof GdbusModemMessagingSkeleton;
        abstract class GdbusModemMessagingSkeletonPrivate {
            static $gtype: GObject.GType<GdbusModemMessagingSkeletonPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type GdbusModemOmaIface = typeof GdbusModemOma;
        type GdbusModemOmaProxyClass = typeof GdbusModemOmaProxy;
        abstract class GdbusModemOmaProxyPrivate {
            static $gtype: GObject.GType<GdbusModemOmaProxyPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type GdbusModemOmaSkeletonClass = typeof GdbusModemOmaSkeleton;
        abstract class GdbusModemOmaSkeletonPrivate {
            static $gtype: GObject.GType<GdbusModemOmaSkeletonPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type GdbusModemProxyClass = typeof GdbusModemProxy;
        abstract class GdbusModemProxyPrivate {
            static $gtype: GObject.GType<GdbusModemProxyPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type GdbusModemSarIface = typeof GdbusModemSar;
        type GdbusModemSarProxyClass = typeof GdbusModemSarProxy;
        abstract class GdbusModemSarProxyPrivate {
            static $gtype: GObject.GType<GdbusModemSarProxyPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type GdbusModemSarSkeletonClass = typeof GdbusModemSarSkeleton;
        abstract class GdbusModemSarSkeletonPrivate {
            static $gtype: GObject.GType<GdbusModemSarSkeletonPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type GdbusModemSignalIface = typeof GdbusModemSignal;
        type GdbusModemSignalProxyClass = typeof GdbusModemSignalProxy;
        abstract class GdbusModemSignalProxyPrivate {
            static $gtype: GObject.GType<GdbusModemSignalProxyPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type GdbusModemSignalSkeletonClass = typeof GdbusModemSignalSkeleton;
        abstract class GdbusModemSignalSkeletonPrivate {
            static $gtype: GObject.GType<GdbusModemSignalSkeletonPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type GdbusModemSimpleIface = typeof GdbusModemSimple;
        type GdbusModemSimpleProxyClass = typeof GdbusModemSimpleProxy;
        abstract class GdbusModemSimpleProxyPrivate {
            static $gtype: GObject.GType<GdbusModemSimpleProxyPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type GdbusModemSimpleSkeletonClass = typeof GdbusModemSimpleSkeleton;
        abstract class GdbusModemSimpleSkeletonPrivate {
            static $gtype: GObject.GType<GdbusModemSimpleSkeletonPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type GdbusModemSkeletonClass = typeof GdbusModemSkeleton;
        abstract class GdbusModemSkeletonPrivate {
            static $gtype: GObject.GType<GdbusModemSkeletonPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type GdbusModemTimeIface = typeof GdbusModemTime;
        type GdbusModemTimeProxyClass = typeof GdbusModemTimeProxy;
        abstract class GdbusModemTimeProxyPrivate {
            static $gtype: GObject.GType<GdbusModemTimeProxyPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type GdbusModemTimeSkeletonClass = typeof GdbusModemTimeSkeleton;
        abstract class GdbusModemTimeSkeletonPrivate {
            static $gtype: GObject.GType<GdbusModemTimeSkeletonPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type GdbusModemVoiceIface = typeof GdbusModemVoice;
        type GdbusModemVoiceProxyClass = typeof GdbusModemVoiceProxy;
        abstract class GdbusModemVoiceProxyPrivate {
            static $gtype: GObject.GType<GdbusModemVoiceProxyPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type GdbusModemVoiceSkeletonClass = typeof GdbusModemVoiceSkeleton;
        abstract class GdbusModemVoiceSkeletonPrivate {
            static $gtype: GObject.GType<GdbusModemVoiceSkeletonPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type GdbusObjectIface = typeof GdbusObject;
        type GdbusObjectManagerClientClass = typeof GdbusObjectManagerClient;
        abstract class GdbusObjectManagerClientPrivate {
            static $gtype: GObject.GType<GdbusObjectManagerClientPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type GdbusObjectProxyClass = typeof GdbusObjectProxy;
        abstract class GdbusObjectProxyPrivate {
            static $gtype: GObject.GType<GdbusObjectProxyPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type GdbusObjectSkeletonClass = typeof GdbusObjectSkeleton;
        abstract class GdbusObjectSkeletonPrivate {
            static $gtype: GObject.GType<GdbusObjectSkeletonPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type GdbusOrgFreedesktopModemManager1Iface = typeof GdbusOrgFreedesktopModemManager1;
        type GdbusOrgFreedesktopModemManager1ProxyClass = typeof GdbusOrgFreedesktopModemManager1Proxy;
        abstract class GdbusOrgFreedesktopModemManager1ProxyPrivate {
            static $gtype: GObject.GType<GdbusOrgFreedesktopModemManager1ProxyPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type GdbusOrgFreedesktopModemManager1SkeletonClass = typeof GdbusOrgFreedesktopModemManager1Skeleton;
        abstract class GdbusOrgFreedesktopModemManager1SkeletonPrivate {
            static $gtype: GObject.GType<GdbusOrgFreedesktopModemManager1SkeletonPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type GdbusSimIface = typeof GdbusSim;
        type GdbusSimProxyClass = typeof GdbusSimProxy;
        abstract class GdbusSimProxyPrivate {
            static $gtype: GObject.GType<GdbusSimProxyPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type GdbusSimSkeletonClass = typeof GdbusSimSkeleton;
        abstract class GdbusSimSkeletonPrivate {
            static $gtype: GObject.GType<GdbusSimSkeletonPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type GdbusSmsIface = typeof GdbusSms;
        type GdbusSmsProxyClass = typeof GdbusSmsProxy;
        abstract class GdbusSmsProxyPrivate {
            static $gtype: GObject.GType<GdbusSmsProxyPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type GdbusSmsSkeletonClass = typeof GdbusSmsSkeleton;
        abstract class GdbusSmsSkeletonPrivate {
            static $gtype: GObject.GType<GdbusSmsSkeletonPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type KernelEventPropertiesClass = typeof KernelEventProperties;
        abstract class KernelEventPropertiesPrivate {
            static $gtype: GObject.GType<KernelEventPropertiesPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type Location3gppClass = typeof Location3gpp;
        abstract class Location3gppPrivate {
            static $gtype: GObject.GType<Location3gppPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type LocationCdmaBsClass = typeof LocationCdmaBs;
        abstract class LocationCdmaBsPrivate {
            static $gtype: GObject.GType<LocationCdmaBsPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type LocationGpsNmeaClass = typeof LocationGpsNmea;
        abstract class LocationGpsNmeaPrivate {
            static $gtype: GObject.GType<LocationGpsNmeaPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type LocationGpsRawClass = typeof LocationGpsRaw;
        abstract class LocationGpsRawPrivate {
            static $gtype: GObject.GType<LocationGpsRawPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type ManagerClass = typeof Manager;
        abstract class ManagerPrivate {
            static $gtype: GObject.GType<ManagerPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type Modem3gppClass = typeof Modem3gpp;
        /**
         * The #MMModem3gppNetwork structure contains private data and should only be accessed
         * using the provided API.
         */
        abstract class Modem3gppNetwork {
            static $gtype: GObject.GType<Modem3gppNetwork>;

            // Constructors

            _init(...args: any[]): void;

            // Methods

            /**
             * Frees a #MMModem3gppNetwork.
             */
            free(): void;
            /**
             * Get the technology used to access the 3GPP network.
             * @returns A #MMModemAccessTechnology.
             */
            get_access_technology(): ModemAccessTechnology;
            /**
             * Get availability of the 3GPP network.
             * @returns A #MMModem3gppNetworkAvailability.
             */
            get_availability(): Modem3gppNetworkAvailability;
            /**
             * Get the operator code (MCCMNC) of the 3GPP network.
             * @returns The operator code, or %NULL if none available.
             */
            get_operator_code(): string;
            /**
             * Get the long operator name of the 3GPP network.
             * @returns The long operator name, or %NULL if none available.
             */
            get_operator_long(): string;
            /**
             * Get the short operator name of the 3GPP network.
             * @returns The long operator name, or %NULL if none available.
             */
            get_operator_short(): string;
        }

        abstract class Modem3gppPrivate {
            static $gtype: GObject.GType<Modem3gppPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type Modem3gppProfileManagerClass = typeof Modem3gppProfileManager;
        type Modem3gppUssdClass = typeof Modem3gppUssd;
        type ModemCdmaClass = typeof ModemCdma;
        type ModemClass = typeof Modem;
        type ModemFirmwareClass = typeof ModemFirmware;
        abstract class ModemFirmwarePrivate {
            static $gtype: GObject.GType<ModemFirmwarePrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type ModemLocationClass = typeof ModemLocation;
        abstract class ModemLocationPrivate {
            static $gtype: GObject.GType<ModemLocationPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type ModemMessagingClass = typeof ModemMessaging;
        abstract class ModemMessagingPrivate {
            static $gtype: GObject.GType<ModemMessagingPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        /**
         * #MMModemModeCombination is a simple struct holding a pair of #MMModemMode
         * values.
         */
        class ModemModeCombination {
            static $gtype: GObject.GType<ModemModeCombination>;

            // Fields

            allowed: ModemMode;
            preferred: ModemMode;

            // Constructors

            _init(...args: any[]): void;
        }

        type ModemOmaClass = typeof ModemOma;
        abstract class ModemOmaPrivate {
            static $gtype: GObject.GType<ModemOmaPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        /**
         * Information of a given port.
         */
        class ModemPortInfo {
            static $gtype: GObject.GType<ModemPortInfo>;

            // Fields

            name: string;
            type: ModemPortType;

            // Constructors

            _init(...args: any[]): void;

            // Methods

            /**
             * Frees an array of #MMModemPortInfo values.
             * @param array_size length of @array.
             */
            array_free(array_size: number): void;
        }

        abstract class ModemPrivate {
            static $gtype: GObject.GType<ModemPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type ModemSarClass = typeof ModemSar;
        type ModemSignalClass = typeof ModemSignal;
        abstract class ModemSignalPrivate {
            static $gtype: GObject.GType<ModemSignalPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type ModemSimpleClass = typeof ModemSimple;
        type ModemTimeClass = typeof ModemTime;
        abstract class ModemTimePrivate {
            static $gtype: GObject.GType<ModemTimePrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type ModemVoiceClass = typeof ModemVoice;
        abstract class ModemVoicePrivate {
            static $gtype: GObject.GType<ModemVoicePrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type NetworkTimezoneClass = typeof NetworkTimezone;
        abstract class NetworkTimezonePrivate {
            static $gtype: GObject.GType<NetworkTimezonePrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type Nr5gRegistrationSettingsClass = typeof Nr5gRegistrationSettings;
        abstract class Nr5gRegistrationSettingsPrivate {
            static $gtype: GObject.GType<Nr5gRegistrationSettingsPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type ObjectClass = typeof Object;
        /**
         * #MMOmaPendingNetworkInitiatedSession is a simple struct specifying the
         * information available for a pending network-initiated OMA session.
         */
        class OmaPendingNetworkInitiatedSession {
            static $gtype: GObject.GType<OmaPendingNetworkInitiatedSession>;

            // Fields

            session_type: OmaSessionType;
            session_id: number;

            // Constructors

            _init(...args: any[]): void;
        }

        type PcoClass = typeof Pco;
        abstract class PcoPrivate {
            static $gtype: GObject.GType<PcoPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type SignalClass = typeof Signal;
        abstract class SignalPrivate {
            static $gtype: GObject.GType<SignalPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type SignalThresholdPropertiesClass = typeof SignalThresholdProperties;
        abstract class SignalThresholdPropertiesPrivate {
            static $gtype: GObject.GType<SignalThresholdPropertiesPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type SimClass = typeof Sim;
        /**
         * The #MMSimPreferredNetwork structure contains private data and should only be accessed
         * using the provided API.
         */
        class SimPreferredNetwork {
            static $gtype: GObject.GType<SimPreferredNetwork>;

            // Constructors

            constructor(properties?: Partial<{}>);
            _init(...args: any[]): void;

            static ['new'](): SimPreferredNetwork;

            // Methods

            /**
             * Frees a #MMSimPreferredNetwork.
             */
            free(): void;
            /**
             * Get the access technology mask of the preferred network.
             * @returns A #MMModemAccessTechnology.
             */
            get_access_technology(): ModemAccessTechnology;
            /**
             * Get the operator code (MCCMNC) of the preferred network.
             * @returns The operator code, or %NULL if none available.
             */
            get_operator_code(): string;
            /**
             * Set the desired access technologies of this preferred network entry.
             * @param access_technology A #MMModemAccessTechnology mask.
             */
            set_access_technology(access_technology: ModemAccessTechnology | null): void;
            /**
             * Set the operator code (MCCMNC) of this preferred network.
             * @param operator_code Operator code
             */
            set_operator_code(operator_code: string): void;
        }

        type SimpleConnectPropertiesClass = typeof SimpleConnectProperties;
        abstract class SimpleConnectPropertiesPrivate {
            static $gtype: GObject.GType<SimpleConnectPropertiesPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type SimpleStatusClass = typeof SimpleStatus;
        abstract class SimpleStatusPrivate {
            static $gtype: GObject.GType<SimpleStatusPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type SmsClass = typeof Sms;
        type SmsPropertiesClass = typeof SmsProperties;
        abstract class SmsPropertiesPrivate {
            static $gtype: GObject.GType<SmsPropertiesPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        type UnlockRetriesClass = typeof UnlockRetries;
        abstract class UnlockRetriesPrivate {
            static $gtype: GObject.GType<UnlockRetriesPrivate>;

            // Constructors

            _init(...args: any[]): void;
        }

        namespace GdbusBearer {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                bearer_type: number;
                bearerType: number;
                connected: boolean;
                connection_error: GLib.Variant;
                connectionError: GLib.Variant;
                interface: string;
                ip_timeout: number;
                ipTimeout: number;
                ip4_config: GLib.Variant;
                ip4Config: GLib.Variant;
                ip6_config: GLib.Variant;
                ip6Config: GLib.Variant;
                multiplexed: boolean;
                profile_id: number;
                profileId: number;
                properties: GLib.Variant;
                reload_stats_supported: boolean;
                reloadStatsSupported: boolean;
                stats: GLib.Variant;
                suspended: boolean;
            }
        }

        export interface GdbusBearerNamespace {
            $gtype: GObject.GType<GdbusBearer>;
            prototype: GdbusBearer;

            /**
             * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Bearer.top_of_page">org.freedesktop.ModemManager1.Bearer</link> D-Bus interface.
             */
            interface_info(): Gio.DBusInterfaceInfo;
            /**
             * Overrides all #GObject properties in the #MmGdbusBearer interface for a concrete class.
             * The properties are overridden in the order they are defined.
             * @param klass The class structure for a #GObject derived class.
             * @param property_id_begin The property id to assign to the first overridden property.
             */
            override_properties(klass: typeof GObject.Object, property_id_begin: number): number;
        }
        interface GdbusBearer extends GObject.Object {
            // Properties

            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.BearerType">"BearerType"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get bearer_type(): number;
            set bearer_type(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.BearerType">"BearerType"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get bearerType(): number;
            set bearerType(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.Connected">"Connected"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get connected(): boolean;
            set connected(val: boolean);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.ConnectionError">"ConnectionError"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get connection_error(): GLib.Variant;
            set connection_error(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.ConnectionError">"ConnectionError"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get connectionError(): GLib.Variant;
            set connectionError(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.Interface">"Interface"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get 'interface'(): string;
            set 'interface'(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.IpTimeout">"IpTimeout"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get ip_timeout(): number;
            set ip_timeout(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.IpTimeout">"IpTimeout"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get ipTimeout(): number;
            set ipTimeout(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.Ip4Config">"Ip4Config"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get ip4_config(): GLib.Variant;
            set ip4_config(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.Ip4Config">"Ip4Config"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get ip4Config(): GLib.Variant;
            set ip4Config(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.Ip6Config">"Ip6Config"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get ip6_config(): GLib.Variant;
            set ip6_config(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.Ip6Config">"Ip6Config"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get ip6Config(): GLib.Variant;
            set ip6Config(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.Multiplexed">"Multiplexed"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get multiplexed(): boolean;
            set multiplexed(val: boolean);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.ProfileId">"ProfileId"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get profile_id(): number;
            set profile_id(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.ProfileId">"ProfileId"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get profileId(): number;
            set profileId(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.Properties">"Properties"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get properties(): GLib.Variant;
            set properties(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.ReloadStatsSupported">"ReloadStatsSupported"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get reload_stats_supported(): boolean;
            set reload_stats_supported(val: boolean);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.ReloadStatsSupported">"ReloadStatsSupported"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get reloadStatsSupported(): boolean;
            set reloadStatsSupported(val: boolean);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.Stats">"Stats"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get stats(): GLib.Variant;
            set stats(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Bearer.Suspended">"Suspended"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get suspended(): boolean;
            set suspended(val: boolean);

            // Methods

            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Bearer.Connect">Connect()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_bearer_call_connect_finish() to get the result of the operation.
             *
             * See mm_gdbus_bearer_call_connect_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_connect(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Bearer.Connect">Connect()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_bearer_call_connect_finish() to get the result of the operation.
             *
             * See mm_gdbus_bearer_call_connect_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_connect(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Bearer.Connect">Connect()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_bearer_call_connect_finish() to get the result of the operation.
             *
             * See mm_gdbus_bearer_call_connect_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_connect(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_bearer_call_connect().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_bearer_call_connect().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_connect_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Bearer.Connect">Connect()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_bearer_call_connect() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_connect_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Bearer.Disconnect">Disconnect()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_bearer_call_disconnect_finish() to get the result of the operation.
             *
             * See mm_gdbus_bearer_call_disconnect_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_disconnect(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Bearer.Disconnect">Disconnect()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_bearer_call_disconnect_finish() to get the result of the operation.
             *
             * See mm_gdbus_bearer_call_disconnect_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_disconnect(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Bearer.Disconnect">Disconnect()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_bearer_call_disconnect_finish() to get the result of the operation.
             *
             * See mm_gdbus_bearer_call_disconnect_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_disconnect(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_bearer_call_disconnect().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_bearer_call_disconnect().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_disconnect_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Bearer.Disconnect">Disconnect()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_bearer_call_disconnect() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_disconnect_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Bearer.Connect">Connect()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_connect(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Bearer.Disconnect">Disconnect()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_disconnect(invocation: Gio.DBusMethodInvocation): void;

            // Virtual methods

            vfunc_handle_connect(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_disconnect(invocation: Gio.DBusMethodInvocation): boolean;
        }

        export const GdbusBearer: GdbusBearerNamespace & {
            new (): GdbusBearer; // This allows `obj instanceof GdbusBearer`
        };

        namespace GdbusCall {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                audio_format: GLib.Variant;
                audioFormat: GLib.Variant;
                audio_port: string;
                audioPort: string;
                direction: number;
                multiparty: boolean;
                number: string;
                state: number;
                state_reason: number;
                stateReason: number;
            }
        }

        export interface GdbusCallNamespace {
            $gtype: GObject.GType<GdbusCall>;
            prototype: GdbusCall;

            /**
             * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Call.top_of_page">org.freedesktop.ModemManager1.Call</link> D-Bus interface.
             */
            interface_info(): Gio.DBusInterfaceInfo;
            /**
             * Overrides all #GObject properties in the #MmGdbusCall interface for a concrete class.
             * The properties are overridden in the order they are defined.
             * @param klass The class structure for a #GObject derived class.
             * @param property_id_begin The property id to assign to the first overridden property.
             */
            override_properties(klass: typeof GObject.Object, property_id_begin: number): number;
        }
        interface GdbusCall extends GObject.Object {
            // Properties

            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Call.AudioFormat">"AudioFormat"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get audio_format(): GLib.Variant;
            set audio_format(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Call.AudioFormat">"AudioFormat"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get audioFormat(): GLib.Variant;
            set audioFormat(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Call.AudioPort">"AudioPort"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get audio_port(): string;
            set audio_port(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Call.AudioPort">"AudioPort"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get audioPort(): string;
            set audioPort(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Call.Direction">"Direction"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get direction(): number;
            set direction(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Call.Multiparty">"Multiparty"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get multiparty(): boolean;
            set multiparty(val: boolean);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Call.Number">"Number"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get number(): string;
            set number(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Call.State">"State"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get state(): number;
            set state(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Call.StateReason">"StateReason"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get state_reason(): number;
            set state_reason(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Call.StateReason">"StateReason"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get stateReason(): number;
            set stateReason(val: number);

            // Methods

            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Accept">Accept()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_accept_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_accept_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_accept(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Accept">Accept()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_accept_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_accept_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_accept(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Accept">Accept()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_accept_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_accept_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_accept(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_call_call_accept().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_call_call_accept().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_accept_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Accept">Accept()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_call_call_accept() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_accept_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Deflect">Deflect()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_deflect_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_deflect_sync() for the synchronous, blocking version of this method.
             * @param arg_number Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_deflect(arg_number: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Deflect">Deflect()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_deflect_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_deflect_sync() for the synchronous, blocking version of this method.
             * @param arg_number Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_deflect(
                arg_number: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Deflect">Deflect()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_deflect_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_deflect_sync() for the synchronous, blocking version of this method.
             * @param arg_number Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_deflect(
                arg_number: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_call_call_deflect().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_call_call_deflect().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_deflect_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Deflect">Deflect()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_call_call_deflect() for the asynchronous version of this method.
             * @param arg_number Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_deflect_sync(arg_number: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Hangup">Hangup()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_hangup_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_hangup_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_hangup(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Hangup">Hangup()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_hangup_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_hangup_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_hangup(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Hangup">Hangup()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_hangup_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_hangup_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_hangup(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_call_call_hangup().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_call_call_hangup().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_hangup_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Hangup">Hangup()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_call_call_hangup() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_hangup_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.JoinMultiparty">JoinMultiparty()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_join_multiparty_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_join_multiparty_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_join_multiparty(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.JoinMultiparty">JoinMultiparty()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_join_multiparty_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_join_multiparty_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_join_multiparty(
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.JoinMultiparty">JoinMultiparty()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_join_multiparty_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_join_multiparty_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_join_multiparty(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_call_call_join_multiparty().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_call_call_join_multiparty().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_join_multiparty_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.JoinMultiparty">JoinMultiparty()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_call_call_join_multiparty() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_join_multiparty_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.LeaveMultiparty">LeaveMultiparty()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_leave_multiparty_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_leave_multiparty_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_leave_multiparty(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.LeaveMultiparty">LeaveMultiparty()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_leave_multiparty_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_leave_multiparty_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_leave_multiparty(
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.LeaveMultiparty">LeaveMultiparty()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_leave_multiparty_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_leave_multiparty_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_leave_multiparty(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_call_call_leave_multiparty().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_call_call_leave_multiparty().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_leave_multiparty_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.LeaveMultiparty">LeaveMultiparty()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_call_call_leave_multiparty() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_leave_multiparty_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.SendDtmf">SendDtmf()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_send_dtmf_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_send_dtmf_sync() for the synchronous, blocking version of this method.
             * @param arg_dtmf Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_send_dtmf(arg_dtmf: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.SendDtmf">SendDtmf()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_send_dtmf_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_send_dtmf_sync() for the synchronous, blocking version of this method.
             * @param arg_dtmf Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_send_dtmf(
                arg_dtmf: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.SendDtmf">SendDtmf()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_send_dtmf_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_send_dtmf_sync() for the synchronous, blocking version of this method.
             * @param arg_dtmf Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_send_dtmf(
                arg_dtmf: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_call_call_send_dtmf().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_call_call_send_dtmf().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_send_dtmf_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.SendDtmf">SendDtmf()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_call_call_send_dtmf() for the asynchronous version of this method.
             * @param arg_dtmf Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_send_dtmf_sync(arg_dtmf: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Start">Start()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_start_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_start_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_start(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Start">Start()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_start_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_start_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_start(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Start">Start()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_call_call_start_finish() to get the result of the operation.
             *
             * See mm_gdbus_call_call_start_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_start(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_call_call_start().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_call_call_start().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_start_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Start">Start()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_call_call_start() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_start_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Accept">Accept()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_accept(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Deflect">Deflect()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_deflect(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Hangup">Hangup()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_hangup(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.JoinMultiparty">JoinMultiparty()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_join_multiparty(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.LeaveMultiparty">LeaveMultiparty()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_leave_multiparty(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.SendDtmf">SendDtmf()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_send_dtmf(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Call.Start">Start()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_start(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Emits the <link linkend="gdbus-signal-org-freedesktop-ModemManager1-Call.DtmfReceived">"DtmfReceived"</link> D-Bus signal.
             * @param arg_dtmf Argument to pass with the signal.
             */
            emit_dtmf_received(arg_dtmf: string): void;
            /**
             * Emits the <link linkend="gdbus-signal-org-freedesktop-ModemManager1-Call.StateChanged">"StateChanged"</link> D-Bus signal.
             * @param arg_old Argument to pass with the signal.
             * @param arg_new Argument to pass with the signal.
             * @param arg_reason Argument to pass with the signal.
             */
            emit_state_changed(arg_old: number, arg_new: number, arg_reason: number): void;

            // Virtual methods

            vfunc_dtmf_received(arg_dtmf: string): void;
            vfunc_handle_accept(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_deflect(invocation: Gio.DBusMethodInvocation, arg_number: string): boolean;
            vfunc_handle_hangup(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_join_multiparty(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_leave_multiparty(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_send_dtmf(invocation: Gio.DBusMethodInvocation, arg_dtmf: string): boolean;
            vfunc_handle_start(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_state_changed(arg_old: number, arg_new: number, arg_reason: number): void;
        }

        export const GdbusCall: GdbusCallNamespace & {
            new (): GdbusCall; // This allows `obj instanceof GdbusCall`
        };

        namespace GdbusModem {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                access_technologies: number;
                accessTechnologies: number;
                bearers: string[];
                carrier_configuration: string;
                carrierConfiguration: string;
                carrier_configuration_revision: string;
                carrierConfigurationRevision: string;
                current_bands: GLib.Variant;
                currentBands: GLib.Variant;
                current_capabilities: number;
                currentCapabilities: number;
                current_modes: GLib.Variant;
                currentModes: GLib.Variant;
                device: string;
                device_identifier: string;
                deviceIdentifier: string;
                drivers: string[];
                equipment_identifier: string;
                equipmentIdentifier: string;
                hardware_revision: string;
                hardwareRevision: string;
                manufacturer: string;
                max_active_bearers: number;
                maxActiveBearers: number;
                max_active_multiplexed_bearers: number;
                maxActiveMultiplexedBearers: number;
                max_bearers: number;
                maxBearers: number;
                model: string;
                own_numbers: string[];
                ownNumbers: string[];
                physdev: string;
                plugin: string;
                ports: GLib.Variant;
                power_state: number;
                powerState: number;
                primary_port: string;
                primaryPort: string;
                primary_sim_slot: number;
                primarySimSlot: number;
                revision: string;
                signal_quality: GLib.Variant;
                signalQuality: GLib.Variant;
                sim: string;
                sim_slots: string[];
                simSlots: string[];
                state: number;
                state_failed_reason: number;
                stateFailedReason: number;
                supported_bands: GLib.Variant;
                supportedBands: GLib.Variant;
                supported_capabilities: GLib.Variant;
                supportedCapabilities: GLib.Variant;
                supported_ip_families: number;
                supportedIpFamilies: number;
                supported_modes: GLib.Variant;
                supportedModes: GLib.Variant;
                unlock_required: number;
                unlockRequired: number;
                unlock_retries: GLib.Variant;
                unlockRetries: GLib.Variant;
            }
        }

        export interface GdbusModemNamespace {
            $gtype: GObject.GType<GdbusModem>;
            prototype: GdbusModem;

            /**
             * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem.top_of_page">org.freedesktop.ModemManager1.Modem</link> D-Bus interface.
             */
            interface_info(): Gio.DBusInterfaceInfo;
            /**
             * Overrides all #GObject properties in the #MmGdbusModem interface for a concrete class.
             * The properties are overridden in the order they are defined.
             * @param klass The class structure for a #GObject derived class.
             * @param property_id_begin The property id to assign to the first overridden property.
             */
            override_properties(klass: typeof GObject.Object, property_id_begin: number): number;
        }
        interface GdbusModem extends GObject.Object {
            // Properties

            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.AccessTechnologies">"AccessTechnologies"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get access_technologies(): number;
            set access_technologies(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.AccessTechnologies">"AccessTechnologies"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get accessTechnologies(): number;
            set accessTechnologies(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.Bearers">"Bearers"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get bearers(): string[];
            set bearers(val: string[]);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.CarrierConfiguration">"CarrierConfiguration"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get carrier_configuration(): string;
            set carrier_configuration(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.CarrierConfiguration">"CarrierConfiguration"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get carrierConfiguration(): string;
            set carrierConfiguration(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.CarrierConfigurationRevision">"CarrierConfigurationRevision"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get carrier_configuration_revision(): string;
            set carrier_configuration_revision(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.CarrierConfigurationRevision">"CarrierConfigurationRevision"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get carrierConfigurationRevision(): string;
            set carrierConfigurationRevision(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.CurrentBands">"CurrentBands"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get current_bands(): GLib.Variant;
            set current_bands(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.CurrentBands">"CurrentBands"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get currentBands(): GLib.Variant;
            set currentBands(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.CurrentCapabilities">"CurrentCapabilities"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get current_capabilities(): number;
            set current_capabilities(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.CurrentCapabilities">"CurrentCapabilities"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get currentCapabilities(): number;
            set currentCapabilities(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.CurrentModes">"CurrentModes"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get current_modes(): GLib.Variant;
            set current_modes(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.CurrentModes">"CurrentModes"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get currentModes(): GLib.Variant;
            set currentModes(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.Device">"Device"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get device(): string;
            set device(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.DeviceIdentifier">"DeviceIdentifier"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get device_identifier(): string;
            set device_identifier(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.DeviceIdentifier">"DeviceIdentifier"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get deviceIdentifier(): string;
            set deviceIdentifier(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.Drivers">"Drivers"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get drivers(): string[];
            set drivers(val: string[]);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.EquipmentIdentifier">"EquipmentIdentifier"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get equipment_identifier(): string;
            set equipment_identifier(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.EquipmentIdentifier">"EquipmentIdentifier"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get equipmentIdentifier(): string;
            set equipmentIdentifier(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.HardwareRevision">"HardwareRevision"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get hardware_revision(): string;
            set hardware_revision(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.HardwareRevision">"HardwareRevision"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get hardwareRevision(): string;
            set hardwareRevision(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.Manufacturer">"Manufacturer"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get manufacturer(): string;
            set manufacturer(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.MaxActiveBearers">"MaxActiveBearers"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get max_active_bearers(): number;
            set max_active_bearers(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.MaxActiveBearers">"MaxActiveBearers"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get maxActiveBearers(): number;
            set maxActiveBearers(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.MaxActiveMultiplexedBearers">"MaxActiveMultiplexedBearers"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get max_active_multiplexed_bearers(): number;
            set max_active_multiplexed_bearers(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.MaxActiveMultiplexedBearers">"MaxActiveMultiplexedBearers"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get maxActiveMultiplexedBearers(): number;
            set maxActiveMultiplexedBearers(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.MaxBearers">"MaxBearers"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get max_bearers(): number;
            set max_bearers(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.MaxBearers">"MaxBearers"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get maxBearers(): number;
            set maxBearers(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.Model">"Model"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get model(): string;
            set model(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.OwnNumbers">"OwnNumbers"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get own_numbers(): string[];
            set own_numbers(val: string[]);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.OwnNumbers">"OwnNumbers"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get ownNumbers(): string[];
            set ownNumbers(val: string[]);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.Physdev">"Physdev"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get physdev(): string;
            set physdev(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.Plugin">"Plugin"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get plugin(): string;
            set plugin(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.Ports">"Ports"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get ports(): GLib.Variant;
            set ports(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.PowerState">"PowerState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get power_state(): number;
            set power_state(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.PowerState">"PowerState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get powerState(): number;
            set powerState(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.PrimaryPort">"PrimaryPort"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get primary_port(): string;
            set primary_port(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.PrimaryPort">"PrimaryPort"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get primaryPort(): string;
            set primaryPort(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.PrimarySimSlot">"PrimarySimSlot"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get primary_sim_slot(): number;
            set primary_sim_slot(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.PrimarySimSlot">"PrimarySimSlot"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get primarySimSlot(): number;
            set primarySimSlot(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.Revision">"Revision"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get revision(): string;
            set revision(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.SignalQuality">"SignalQuality"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get signal_quality(): GLib.Variant;
            set signal_quality(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.SignalQuality">"SignalQuality"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get signalQuality(): GLib.Variant;
            set signalQuality(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.Sim">"Sim"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get sim(): string;
            set sim(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.SimSlots">"SimSlots"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get sim_slots(): string[];
            set sim_slots(val: string[]);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.SimSlots">"SimSlots"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get simSlots(): string[];
            set simSlots(val: string[]);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.State">"State"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get state(): number;
            set state(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.StateFailedReason">"StateFailedReason"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get state_failed_reason(): number;
            set state_failed_reason(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.StateFailedReason">"StateFailedReason"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get stateFailedReason(): number;
            set stateFailedReason(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.SupportedBands">"SupportedBands"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get supported_bands(): GLib.Variant;
            set supported_bands(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.SupportedBands">"SupportedBands"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get supportedBands(): GLib.Variant;
            set supportedBands(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.SupportedCapabilities">"SupportedCapabilities"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get supported_capabilities(): GLib.Variant;
            set supported_capabilities(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.SupportedCapabilities">"SupportedCapabilities"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get supportedCapabilities(): GLib.Variant;
            set supportedCapabilities(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.SupportedIpFamilies">"SupportedIpFamilies"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get supported_ip_families(): number;
            set supported_ip_families(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.SupportedIpFamilies">"SupportedIpFamilies"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get supportedIpFamilies(): number;
            set supportedIpFamilies(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.SupportedModes">"SupportedModes"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get supported_modes(): GLib.Variant;
            set supported_modes(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.SupportedModes">"SupportedModes"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get supportedModes(): GLib.Variant;
            set supportedModes(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.UnlockRequired">"UnlockRequired"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get unlock_required(): number;
            set unlock_required(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.UnlockRequired">"UnlockRequired"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get unlockRequired(): number;
            set unlockRequired(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.UnlockRetries">"UnlockRetries"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get unlock_retries(): GLib.Variant;
            set unlock_retries(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem.UnlockRetries">"UnlockRetries"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get unlockRetries(): GLib.Variant;
            set unlockRetries(val: GLib.Variant);

            // Methods

            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.Command">Command()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_command_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_command_sync() for the synchronous, blocking version of this method.
             * @param arg_cmd Argument to pass with the method invocation.
             * @param arg_timeout Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_command(arg_cmd: string, arg_timeout: number, cancellable?: Gio.Cancellable | null): Promise<string>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.Command">Command()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_command_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_command_sync() for the synchronous, blocking version of this method.
             * @param arg_cmd Argument to pass with the method invocation.
             * @param arg_timeout Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_command(
                arg_cmd: string,
                arg_timeout: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.Command">Command()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_command_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_command_sync() for the synchronous, blocking version of this method.
             * @param arg_cmd Argument to pass with the method invocation.
             * @param arg_timeout Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_command(
                arg_cmd: string,
                arg_timeout: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<string> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_call_command().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_call_command().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_command_finish(res: Gio.AsyncResult): [boolean, string];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.Command">Command()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_call_command() for the asynchronous version of this method.
             * @param arg_cmd Argument to pass with the method invocation.
             * @param arg_timeout Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_command_sync(
                arg_cmd: string,
                arg_timeout: number,
                cancellable?: Gio.Cancellable | null,
            ): [boolean, string];
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.CreateBearer">CreateBearer()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_create_bearer_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_create_bearer_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_create_bearer(arg_properties: GLib.Variant, cancellable?: Gio.Cancellable | null): Promise<string>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.CreateBearer">CreateBearer()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_create_bearer_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_create_bearer_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_create_bearer(
                arg_properties: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.CreateBearer">CreateBearer()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_create_bearer_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_create_bearer_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_create_bearer(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<string> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_call_create_bearer().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_call_create_bearer().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_create_bearer_finish(res: Gio.AsyncResult): [boolean, string];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.CreateBearer">CreateBearer()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_call_create_bearer() for the asynchronous version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_create_bearer_sync(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
            ): [boolean, string];
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.DeleteBearer">DeleteBearer()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_delete_bearer_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_delete_bearer_sync() for the synchronous, blocking version of this method.
             * @param arg_bearer Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_delete_bearer(arg_bearer: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.DeleteBearer">DeleteBearer()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_delete_bearer_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_delete_bearer_sync() for the synchronous, blocking version of this method.
             * @param arg_bearer Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_delete_bearer(
                arg_bearer: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.DeleteBearer">DeleteBearer()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_delete_bearer_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_delete_bearer_sync() for the synchronous, blocking version of this method.
             * @param arg_bearer Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_delete_bearer(
                arg_bearer: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_call_delete_bearer().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_call_delete_bearer().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_delete_bearer_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.DeleteBearer">DeleteBearer()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_call_delete_bearer() for the asynchronous version of this method.
             * @param arg_bearer Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_delete_bearer_sync(arg_bearer: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.Enable">Enable()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_enable_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_enable_sync() for the synchronous, blocking version of this method.
             * @param arg_enable Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_enable(arg_enable: boolean, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.Enable">Enable()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_enable_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_enable_sync() for the synchronous, blocking version of this method.
             * @param arg_enable Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_enable(
                arg_enable: boolean,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.Enable">Enable()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_enable_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_enable_sync() for the synchronous, blocking version of this method.
             * @param arg_enable Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_enable(
                arg_enable: boolean,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_call_enable().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_call_enable().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_enable_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.Enable">Enable()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_call_enable() for the asynchronous version of this method.
             * @param arg_enable Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_enable_sync(arg_enable: boolean, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.FactoryReset">FactoryReset()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_factory_reset_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_factory_reset_sync() for the synchronous, blocking version of this method.
             * @param arg_code Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_factory_reset(arg_code: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.FactoryReset">FactoryReset()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_factory_reset_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_factory_reset_sync() for the synchronous, blocking version of this method.
             * @param arg_code Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_factory_reset(
                arg_code: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.FactoryReset">FactoryReset()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_factory_reset_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_factory_reset_sync() for the synchronous, blocking version of this method.
             * @param arg_code Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_factory_reset(
                arg_code: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_call_factory_reset().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_call_factory_reset().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_factory_reset_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.FactoryReset">FactoryReset()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_call_factory_reset() for the asynchronous version of this method.
             * @param arg_code Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_factory_reset_sync(arg_code: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.GetCellInfo">GetCellInfo()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_get_cell_info_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_get_cell_info_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_get_cell_info(cancellable?: Gio.Cancellable | null): Promise<GLib.Variant | null>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.GetCellInfo">GetCellInfo()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_get_cell_info_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_get_cell_info_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_get_cell_info(
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.GetCellInfo">GetCellInfo()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_get_cell_info_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_get_cell_info_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_get_cell_info(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<GLib.Variant | null> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_call_get_cell_info().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_call_get_cell_info().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_get_cell_info_finish(res: Gio.AsyncResult): [boolean, GLib.Variant | null];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.GetCellInfo">GetCellInfo()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_call_get_cell_info() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_get_cell_info_sync(cancellable?: Gio.Cancellable | null): [boolean, GLib.Variant | null];
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.ListBearers">ListBearers()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_list_bearers_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_list_bearers_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_list_bearers(cancellable?: Gio.Cancellable | null): Promise<string[] | null>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.ListBearers">ListBearers()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_list_bearers_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_list_bearers_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_list_bearers(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.ListBearers">ListBearers()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_list_bearers_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_list_bearers_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_list_bearers(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<string[] | null> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_call_list_bearers().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_call_list_bearers().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_list_bearers_finish(res: Gio.AsyncResult): [boolean, string[] | null];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.ListBearers">ListBearers()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_call_list_bearers() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_list_bearers_sync(cancellable?: Gio.Cancellable | null): [boolean, string[] | null];
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.Reset">Reset()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_reset_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_reset_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_reset(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.Reset">Reset()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_reset_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_reset_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_reset(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.Reset">Reset()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_reset_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_reset_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_reset(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_call_reset().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_call_reset().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_reset_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.Reset">Reset()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_call_reset() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_reset_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetCurrentBands">SetCurrentBands()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_set_current_bands_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_set_current_bands_sync() for the synchronous, blocking version of this method.
             * @param arg_bands Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set_current_bands(arg_bands: GLib.Variant, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetCurrentBands">SetCurrentBands()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_set_current_bands_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_set_current_bands_sync() for the synchronous, blocking version of this method.
             * @param arg_bands Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_current_bands(
                arg_bands: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetCurrentBands">SetCurrentBands()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_set_current_bands_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_set_current_bands_sync() for the synchronous, blocking version of this method.
             * @param arg_bands Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_current_bands(
                arg_bands: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_call_set_current_bands().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_call_set_current_bands().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_current_bands_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetCurrentBands">SetCurrentBands()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_call_set_current_bands() for the asynchronous version of this method.
             * @param arg_bands Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_current_bands_sync(arg_bands: GLib.Variant, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetCurrentCapabilities">SetCurrentCapabilities()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_set_current_capabilities_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_set_current_capabilities_sync() for the synchronous, blocking version of this method.
             * @param arg_capabilities Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set_current_capabilities(
                arg_capabilities: number,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetCurrentCapabilities">SetCurrentCapabilities()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_set_current_capabilities_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_set_current_capabilities_sync() for the synchronous, blocking version of this method.
             * @param arg_capabilities Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_current_capabilities(
                arg_capabilities: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetCurrentCapabilities">SetCurrentCapabilities()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_set_current_capabilities_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_set_current_capabilities_sync() for the synchronous, blocking version of this method.
             * @param arg_capabilities Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_current_capabilities(
                arg_capabilities: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_call_set_current_capabilities().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_call_set_current_capabilities().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_current_capabilities_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetCurrentCapabilities">SetCurrentCapabilities()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_call_set_current_capabilities() for the asynchronous version of this method.
             * @param arg_capabilities Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_current_capabilities_sync(arg_capabilities: number, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetCurrentModes">SetCurrentModes()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_set_current_modes_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_set_current_modes_sync() for the synchronous, blocking version of this method.
             * @param arg_modes Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set_current_modes(arg_modes: GLib.Variant, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetCurrentModes">SetCurrentModes()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_set_current_modes_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_set_current_modes_sync() for the synchronous, blocking version of this method.
             * @param arg_modes Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_current_modes(
                arg_modes: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetCurrentModes">SetCurrentModes()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_set_current_modes_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_set_current_modes_sync() for the synchronous, blocking version of this method.
             * @param arg_modes Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_current_modes(
                arg_modes: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_call_set_current_modes().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_call_set_current_modes().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_current_modes_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetCurrentModes">SetCurrentModes()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_call_set_current_modes() for the asynchronous version of this method.
             * @param arg_modes Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_current_modes_sync(arg_modes: GLib.Variant, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetPowerState">SetPowerState()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_set_power_state_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_set_power_state_sync() for the synchronous, blocking version of this method.
             * @param arg_state Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set_power_state(arg_state: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetPowerState">SetPowerState()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_set_power_state_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_set_power_state_sync() for the synchronous, blocking version of this method.
             * @param arg_state Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_power_state(
                arg_state: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetPowerState">SetPowerState()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_set_power_state_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_set_power_state_sync() for the synchronous, blocking version of this method.
             * @param arg_state Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_power_state(
                arg_state: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_call_set_power_state().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_call_set_power_state().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_power_state_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetPowerState">SetPowerState()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_call_set_power_state() for the asynchronous version of this method.
             * @param arg_state Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_power_state_sync(arg_state: number, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetPrimarySimSlot">SetPrimarySimSlot()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_set_primary_sim_slot_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_set_primary_sim_slot_sync() for the synchronous, blocking version of this method.
             * @param arg_sim_slot Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set_primary_sim_slot(arg_sim_slot: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetPrimarySimSlot">SetPrimarySimSlot()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_set_primary_sim_slot_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_set_primary_sim_slot_sync() for the synchronous, blocking version of this method.
             * @param arg_sim_slot Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_primary_sim_slot(
                arg_sim_slot: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetPrimarySimSlot">SetPrimarySimSlot()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_call_set_primary_sim_slot_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_call_set_primary_sim_slot_sync() for the synchronous, blocking version of this method.
             * @param arg_sim_slot Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_primary_sim_slot(
                arg_sim_slot: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_call_set_primary_sim_slot().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_call_set_primary_sim_slot().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_primary_sim_slot_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetPrimarySimSlot">SetPrimarySimSlot()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_call_set_primary_sim_slot() for the asynchronous version of this method.
             * @param arg_sim_slot Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_primary_sim_slot_sync(arg_sim_slot: number, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.Command">Command()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param response Parameter to return.
             */
            complete_command(invocation: Gio.DBusMethodInvocation, response: string): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.CreateBearer">CreateBearer()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param path Parameter to return.
             */
            complete_create_bearer(invocation: Gio.DBusMethodInvocation, path: string): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.DeleteBearer">DeleteBearer()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_delete_bearer(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.Enable">Enable()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_enable(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.FactoryReset">FactoryReset()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_factory_reset(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.GetCellInfo">GetCellInfo()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param cell_info Parameter to return.
             */
            complete_get_cell_info(invocation: Gio.DBusMethodInvocation, cell_info: GLib.Variant): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.ListBearers">ListBearers()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param bearers Parameter to return.
             */
            complete_list_bearers(invocation: Gio.DBusMethodInvocation, bearers: string): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.Reset">Reset()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_reset(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetCurrentBands">SetCurrentBands()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_set_current_bands(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetCurrentCapabilities">SetCurrentCapabilities()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_set_current_capabilities(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetCurrentModes">SetCurrentModes()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_set_current_modes(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetPowerState">SetPowerState()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_set_power_state(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem.SetPrimarySimSlot">SetPrimarySimSlot()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_set_primary_sim_slot(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Emits the <link linkend="gdbus-signal-org-freedesktop-ModemManager1-Modem.StateChanged">"StateChanged"</link> D-Bus signal.
             * @param arg_old Argument to pass with the signal.
             * @param arg_new Argument to pass with the signal.
             * @param arg_reason Argument to pass with the signal.
             */
            emit_state_changed(arg_old: number, arg_new: number, arg_reason: number): void;

            // Virtual methods

            vfunc_handle_command(invocation: Gio.DBusMethodInvocation, arg_cmd: string, arg_timeout: number): boolean;
            vfunc_handle_create_bearer(invocation: Gio.DBusMethodInvocation, arg_properties: GLib.Variant): boolean;
            vfunc_handle_delete_bearer(invocation: Gio.DBusMethodInvocation, arg_bearer: string): boolean;
            vfunc_handle_enable(invocation: Gio.DBusMethodInvocation, arg_enable: boolean): boolean;
            vfunc_handle_factory_reset(invocation: Gio.DBusMethodInvocation, arg_code: string): boolean;
            vfunc_handle_get_cell_info(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_list_bearers(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_reset(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_set_current_bands(invocation: Gio.DBusMethodInvocation, arg_bands: GLib.Variant): boolean;
            vfunc_handle_set_current_capabilities(
                invocation: Gio.DBusMethodInvocation,
                arg_capabilities: number,
            ): boolean;
            vfunc_handle_set_current_modes(invocation: Gio.DBusMethodInvocation, arg_modes: GLib.Variant): boolean;
            vfunc_handle_set_power_state(invocation: Gio.DBusMethodInvocation, arg_state: number): boolean;
            vfunc_handle_set_primary_sim_slot(invocation: Gio.DBusMethodInvocation, arg_sim_slot: number): boolean;
            vfunc_state_changed(arg_old: number, arg_new: number, arg_reason: number): void;
        }

        export const GdbusModem: GdbusModemNamespace & {
            new (): GdbusModem; // This allows `obj instanceof GdbusModem`
        };

        namespace GdbusModem3gpp {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                enabled_facility_locks: number;
                enabledFacilityLocks: number;
                eps_ue_mode_operation: number;
                epsUeModeOperation: number;
                imei: string;
                initial_eps_bearer: string;
                initialEpsBearer: string;
                initial_eps_bearer_settings: GLib.Variant;
                initialEpsBearerSettings: GLib.Variant;
                nr5g_registration_settings: GLib.Variant;
                nr5gRegistrationSettings: GLib.Variant;
                operator_code: string;
                operatorCode: string;
                operator_name: string;
                operatorName: string;
                packet_service_state: number;
                packetServiceState: number;
                pco: GLib.Variant;
                registration_state: number;
                registrationState: number;
                subscription_state: number;
                subscriptionState: number;
            }
        }

        export interface GdbusModem3gppNamespace {
            $gtype: GObject.GType<GdbusModem3gpp>;
            prototype: GdbusModem3gpp;

            /**
             * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Modem3gpp.top_of_page">org.freedesktop.ModemManager1.Modem.Modem3gpp</link> D-Bus interface.
             */
            interface_info(): Gio.DBusInterfaceInfo;
            /**
             * Overrides all #GObject properties in the #MmGdbusModem3gpp interface for a concrete class.
             * The properties are overridden in the order they are defined.
             * @param klass The class structure for a #GObject derived class.
             * @param property_id_begin The property id to assign to the first overridden property.
             */
            override_properties(klass: typeof GObject.Object, property_id_begin: number): number;
        }
        interface GdbusModem3gpp extends GObject.Object {
            // Properties

            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.EnabledFacilityLocks">"EnabledFacilityLocks"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get enabled_facility_locks(): number;
            set enabled_facility_locks(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.EnabledFacilityLocks">"EnabledFacilityLocks"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get enabledFacilityLocks(): number;
            set enabledFacilityLocks(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.EpsUeModeOperation">"EpsUeModeOperation"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get eps_ue_mode_operation(): number;
            set eps_ue_mode_operation(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.EpsUeModeOperation">"EpsUeModeOperation"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get epsUeModeOperation(): number;
            set epsUeModeOperation(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.Imei">"Imei"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get imei(): string;
            set imei(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.InitialEpsBearer">"InitialEpsBearer"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get initial_eps_bearer(): string;
            set initial_eps_bearer(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.InitialEpsBearer">"InitialEpsBearer"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get initialEpsBearer(): string;
            set initialEpsBearer(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.InitialEpsBearerSettings">"InitialEpsBearerSettings"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get initial_eps_bearer_settings(): GLib.Variant;
            set initial_eps_bearer_settings(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.InitialEpsBearerSettings">"InitialEpsBearerSettings"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get initialEpsBearerSettings(): GLib.Variant;
            set initialEpsBearerSettings(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.Nr5gRegistrationSettings">"Nr5gRegistrationSettings"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get nr5g_registration_settings(): GLib.Variant;
            set nr5g_registration_settings(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.Nr5gRegistrationSettings">"Nr5gRegistrationSettings"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get nr5gRegistrationSettings(): GLib.Variant;
            set nr5gRegistrationSettings(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.OperatorCode">"OperatorCode"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get operator_code(): string;
            set operator_code(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.OperatorCode">"OperatorCode"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get operatorCode(): string;
            set operatorCode(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.OperatorName">"OperatorName"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get operator_name(): string;
            set operator_name(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.OperatorName">"OperatorName"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get operatorName(): string;
            set operatorName(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.PacketServiceState">"PacketServiceState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get packet_service_state(): number;
            set packet_service_state(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.PacketServiceState">"PacketServiceState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get packetServiceState(): number;
            set packetServiceState(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.Pco">"Pco"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get pco(): GLib.Variant;
            set pco(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.RegistrationState">"RegistrationState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get registration_state(): number;
            set registration_state(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.RegistrationState">"RegistrationState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get registrationState(): number;
            set registrationState(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.SubscriptionState">"SubscriptionState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get subscription_state(): number;
            set subscription_state(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp.SubscriptionState">"SubscriptionState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get subscriptionState(): number;
            set subscriptionState(val: number);

            // Methods

            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.DisableFacilityLock">DisableFacilityLock()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_disable_facility_lock_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_disable_facility_lock_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_disable_facility_lock(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.DisableFacilityLock">DisableFacilityLock()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_disable_facility_lock_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_disable_facility_lock_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_disable_facility_lock(
                arg_properties: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.DisableFacilityLock">DisableFacilityLock()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_disable_facility_lock_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_disable_facility_lock_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_disable_facility_lock(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem3gpp_call_disable_facility_lock().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem3gpp_call_disable_facility_lock().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_disable_facility_lock_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.DisableFacilityLock">DisableFacilityLock()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem3gpp_call_disable_facility_lock() for the asynchronous version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_disable_facility_lock_sync(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
            ): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.Register">Register()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_register_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_register_sync() for the synchronous, blocking version of this method.
             * @param arg_operator_id Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_register(arg_operator_id: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.Register">Register()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_register_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_register_sync() for the synchronous, blocking version of this method.
             * @param arg_operator_id Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_register(
                arg_operator_id: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.Register">Register()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_register_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_register_sync() for the synchronous, blocking version of this method.
             * @param arg_operator_id Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_register(
                arg_operator_id: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem3gpp_call_register().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem3gpp_call_register().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_register_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.Register">Register()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem3gpp_call_register() for the asynchronous version of this method.
             * @param arg_operator_id Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_register_sync(arg_operator_id: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.Scan">Scan()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_scan_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_scan_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_scan(cancellable?: Gio.Cancellable | null): Promise<GLib.Variant | null>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.Scan">Scan()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_scan_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_scan_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_scan(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.Scan">Scan()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_scan_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_scan_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_scan(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<GLib.Variant | null> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem3gpp_call_scan().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem3gpp_call_scan().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_scan_finish(res: Gio.AsyncResult): [boolean, GLib.Variant | null];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.Scan">Scan()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem3gpp_call_scan() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_scan_sync(cancellable?: Gio.Cancellable | null): [boolean, GLib.Variant | null];
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetCarrierLock">SetCarrierLock()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_set_carrier_lock_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_set_carrier_lock_sync() for the synchronous, blocking version of this method.
             * @param arg_data Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set_carrier_lock(arg_data: GLib.Variant, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetCarrierLock">SetCarrierLock()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_set_carrier_lock_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_set_carrier_lock_sync() for the synchronous, blocking version of this method.
             * @param arg_data Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_carrier_lock(
                arg_data: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetCarrierLock">SetCarrierLock()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_set_carrier_lock_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_set_carrier_lock_sync() for the synchronous, blocking version of this method.
             * @param arg_data Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_carrier_lock(
                arg_data: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem3gpp_call_set_carrier_lock().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem3gpp_call_set_carrier_lock().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_carrier_lock_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetCarrierLock">SetCarrierLock()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem3gpp_call_set_carrier_lock() for the asynchronous version of this method.
             * @param arg_data Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_carrier_lock_sync(arg_data: GLib.Variant, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetEpsUeModeOperation">SetEpsUeModeOperation()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_set_eps_ue_mode_operation_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_set_eps_ue_mode_operation_sync() for the synchronous, blocking version of this method.
             * @param arg_mode Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set_eps_ue_mode_operation(arg_mode: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetEpsUeModeOperation">SetEpsUeModeOperation()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_set_eps_ue_mode_operation_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_set_eps_ue_mode_operation_sync() for the synchronous, blocking version of this method.
             * @param arg_mode Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_eps_ue_mode_operation(
                arg_mode: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetEpsUeModeOperation">SetEpsUeModeOperation()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_set_eps_ue_mode_operation_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_set_eps_ue_mode_operation_sync() for the synchronous, blocking version of this method.
             * @param arg_mode Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_eps_ue_mode_operation(
                arg_mode: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem3gpp_call_set_eps_ue_mode_operation().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem3gpp_call_set_eps_ue_mode_operation().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_eps_ue_mode_operation_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetEpsUeModeOperation">SetEpsUeModeOperation()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem3gpp_call_set_eps_ue_mode_operation() for the asynchronous version of this method.
             * @param arg_mode Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_eps_ue_mode_operation_sync(arg_mode: number, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetInitialEpsBearerSettings">SetInitialEpsBearerSettings()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_set_initial_eps_bearer_settings_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_set_initial_eps_bearer_settings_sync() for the synchronous, blocking version of this method.
             * @param arg_settings Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set_initial_eps_bearer_settings(
                arg_settings: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetInitialEpsBearerSettings">SetInitialEpsBearerSettings()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_set_initial_eps_bearer_settings_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_set_initial_eps_bearer_settings_sync() for the synchronous, blocking version of this method.
             * @param arg_settings Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_initial_eps_bearer_settings(
                arg_settings: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetInitialEpsBearerSettings">SetInitialEpsBearerSettings()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_set_initial_eps_bearer_settings_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_set_initial_eps_bearer_settings_sync() for the synchronous, blocking version of this method.
             * @param arg_settings Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_initial_eps_bearer_settings(
                arg_settings: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem3gpp_call_set_initial_eps_bearer_settings().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem3gpp_call_set_initial_eps_bearer_settings().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_initial_eps_bearer_settings_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetInitialEpsBearerSettings">SetInitialEpsBearerSettings()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem3gpp_call_set_initial_eps_bearer_settings() for the asynchronous version of this method.
             * @param arg_settings Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_initial_eps_bearer_settings_sync(
                arg_settings: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
            ): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetNr5gRegistrationSettings">SetNr5gRegistrationSettings()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_set_nr5g_registration_settings_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_set_nr5g_registration_settings_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set_nr5g_registration_settings(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetNr5gRegistrationSettings">SetNr5gRegistrationSettings()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_set_nr5g_registration_settings_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_set_nr5g_registration_settings_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_nr5g_registration_settings(
                arg_properties: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetNr5gRegistrationSettings">SetNr5gRegistrationSettings()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_set_nr5g_registration_settings_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_set_nr5g_registration_settings_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_nr5g_registration_settings(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem3gpp_call_set_nr5g_registration_settings().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem3gpp_call_set_nr5g_registration_settings().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_nr5g_registration_settings_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetNr5gRegistrationSettings">SetNr5gRegistrationSettings()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem3gpp_call_set_nr5g_registration_settings() for the asynchronous version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_nr5g_registration_settings_sync(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
            ): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetPacketServiceState">SetPacketServiceState()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_set_packet_service_state_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_set_packet_service_state_sync() for the synchronous, blocking version of this method.
             * @param arg_state Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set_packet_service_state(arg_state: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetPacketServiceState">SetPacketServiceState()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_set_packet_service_state_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_set_packet_service_state_sync() for the synchronous, blocking version of this method.
             * @param arg_state Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_packet_service_state(
                arg_state: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetPacketServiceState">SetPacketServiceState()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_call_set_packet_service_state_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_call_set_packet_service_state_sync() for the synchronous, blocking version of this method.
             * @param arg_state Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_packet_service_state(
                arg_state: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem3gpp_call_set_packet_service_state().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem3gpp_call_set_packet_service_state().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_packet_service_state_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetPacketServiceState">SetPacketServiceState()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem3gpp_call_set_packet_service_state() for the asynchronous version of this method.
             * @param arg_state Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_packet_service_state_sync(arg_state: number, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.DisableFacilityLock">DisableFacilityLock()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_disable_facility_lock(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.Register">Register()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_register(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.Scan">Scan()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param results Parameter to return.
             */
            complete_scan(invocation: Gio.DBusMethodInvocation, results: GLib.Variant): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetCarrierLock">SetCarrierLock()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_set_carrier_lock(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetEpsUeModeOperation">SetEpsUeModeOperation()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_set_eps_ue_mode_operation(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetInitialEpsBearerSettings">SetInitialEpsBearerSettings()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_set_initial_eps_bearer_settings(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetNr5gRegistrationSettings">SetNr5gRegistrationSettings()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_set_nr5g_registration_settings(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp.SetPacketServiceState">SetPacketServiceState()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_set_packet_service_state(invocation: Gio.DBusMethodInvocation): void;

            // Virtual methods

            vfunc_handle_disable_facility_lock(
                invocation: Gio.DBusMethodInvocation,
                arg_properties: GLib.Variant,
            ): boolean;
            vfunc_handle_register(invocation: Gio.DBusMethodInvocation, arg_operator_id: string): boolean;
            vfunc_handle_scan(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_set_carrier_lock(invocation: Gio.DBusMethodInvocation, arg_data: GLib.Variant): boolean;
            vfunc_handle_set_eps_ue_mode_operation(invocation: Gio.DBusMethodInvocation, arg_mode: number): boolean;
            vfunc_handle_set_initial_eps_bearer_settings(
                invocation: Gio.DBusMethodInvocation,
                arg_settings: GLib.Variant,
            ): boolean;
            vfunc_handle_set_nr5g_registration_settings(
                invocation: Gio.DBusMethodInvocation,
                arg_properties: GLib.Variant,
            ): boolean;
            vfunc_handle_set_packet_service_state(invocation: Gio.DBusMethodInvocation, arg_state: number): boolean;
        }

        export const GdbusModem3gpp: GdbusModem3gppNamespace & {
            new (): GdbusModem3gpp; // This allows `obj instanceof GdbusModem3gpp`
        };

        namespace GdbusModem3gppProfileManager {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                index_field: string;
                indexField: string;
            }
        }

        export interface GdbusModem3gppProfileManagerNamespace {
            $gtype: GObject.GType<GdbusModem3gppProfileManager>;
            prototype: GdbusModem3gppProfileManager;

            /**
             * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.top_of_page">org.freedesktop.ModemManager1.Modem.Modem3gpp.ProfileManager</link> D-Bus interface.
             */
            interface_info(): Gio.DBusInterfaceInfo;
            /**
             * Overrides all #GObject properties in the #MmGdbusModem3gppProfileManager interface for a concrete class.
             * The properties are overridden in the order they are defined.
             * @param klass The class structure for a #GObject derived class.
             * @param property_id_begin The property id to assign to the first overridden property.
             */
            override_properties(klass: typeof GObject.Object, property_id_begin: number): number;
        }
        interface GdbusModem3gppProfileManager extends GObject.Object {
            // Properties

            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.IndexField">"IndexField"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get index_field(): string;
            set index_field(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.IndexField">"IndexField"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get indexField(): string;
            set indexField(val: string);

            // Methods

            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.Delete">Delete()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_profile_manager_call_delete_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_profile_manager_call_delete_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_delete(arg_properties: GLib.Variant, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.Delete">Delete()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_profile_manager_call_delete_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_profile_manager_call_delete_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_delete(
                arg_properties: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.Delete">Delete()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_profile_manager_call_delete_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_profile_manager_call_delete_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_delete(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem3gpp_profile_manager_call_delete().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem3gpp_profile_manager_call_delete().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_delete_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.Delete">Delete()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem3gpp_profile_manager_call_delete() for the asynchronous version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_delete_sync(arg_properties: GLib.Variant, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.List">List()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_profile_manager_call_list_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_profile_manager_call_list_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_list(cancellable?: Gio.Cancellable | null): Promise<GLib.Variant | null>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.List">List()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_profile_manager_call_list_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_profile_manager_call_list_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_list(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.List">List()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_profile_manager_call_list_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_profile_manager_call_list_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_list(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<GLib.Variant | null> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem3gpp_profile_manager_call_list().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem3gpp_profile_manager_call_list().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_list_finish(res: Gio.AsyncResult): [boolean, GLib.Variant | null];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.List">List()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem3gpp_profile_manager_call_list() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_list_sync(cancellable?: Gio.Cancellable | null): [boolean, GLib.Variant | null];
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.Set">Set()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_profile_manager_call_set_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_profile_manager_call_set_sync() for the synchronous, blocking version of this method.
             * @param arg_requested_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set(
                arg_requested_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
            ): Promise<GLib.Variant | null>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.Set">Set()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_profile_manager_call_set_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_profile_manager_call_set_sync() for the synchronous, blocking version of this method.
             * @param arg_requested_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set(
                arg_requested_properties: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.Set">Set()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_profile_manager_call_set_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_profile_manager_call_set_sync() for the synchronous, blocking version of this method.
             * @param arg_requested_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set(
                arg_requested_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<GLib.Variant | null> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem3gpp_profile_manager_call_set().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem3gpp_profile_manager_call_set().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_finish(res: Gio.AsyncResult): [boolean, GLib.Variant | null];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.Set">Set()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem3gpp_profile_manager_call_set() for the asynchronous version of this method.
             * @param arg_requested_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_sync(
                arg_requested_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
            ): [boolean, GLib.Variant | null];
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.Delete">Delete()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_delete(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.List">List()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param profiles Parameter to return.
             */
            complete_list(invocation: Gio.DBusMethodInvocation, profiles: GLib.Variant): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.Set">Set()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param stored_properties Parameter to return.
             */
            complete_set(invocation: Gio.DBusMethodInvocation, stored_properties: GLib.Variant): void;
            /**
             * Emits the <link linkend="gdbus-signal-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.Updated">"Updated"</link> D-Bus signal.
             */
            emit_updated(): void;

            // Virtual methods

            vfunc_handle_delete(invocation: Gio.DBusMethodInvocation, arg_properties: GLib.Variant): boolean;
            vfunc_handle_list(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_set(invocation: Gio.DBusMethodInvocation, arg_requested_properties: GLib.Variant): boolean;
            vfunc_updated(): void;
        }

        export const GdbusModem3gppProfileManager: GdbusModem3gppProfileManagerNamespace & {
            new (): GdbusModem3gppProfileManager; // This allows `obj instanceof GdbusModem3gppProfileManager`
        };

        namespace GdbusModem3gppUssd {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                network_notification: string;
                networkNotification: string;
                network_request: string;
                networkRequest: string;
                state: number;
            }
        }

        export interface GdbusModem3gppUssdNamespace {
            $gtype: GObject.GType<GdbusModem3gppUssd>;
            prototype: GdbusModem3gppUssd;

            /**
             * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.top_of_page">org.freedesktop.ModemManager1.Modem.Modem3gpp.Ussd</link> D-Bus interface.
             */
            interface_info(): Gio.DBusInterfaceInfo;
            /**
             * Overrides all #GObject properties in the #MmGdbusModem3gppUssd interface for a concrete class.
             * The properties are overridden in the order they are defined.
             * @param klass The class structure for a #GObject derived class.
             * @param property_id_begin The property id to assign to the first overridden property.
             */
            override_properties(klass: typeof GObject.Object, property_id_begin: number): number;
        }
        interface GdbusModem3gppUssd extends GObject.Object {
            // Properties

            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.NetworkNotification">"NetworkNotification"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get network_notification(): string;
            set network_notification(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.NetworkNotification">"NetworkNotification"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get networkNotification(): string;
            set networkNotification(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.NetworkRequest">"NetworkRequest"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get network_request(): string;
            set network_request(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.NetworkRequest">"NetworkRequest"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get networkRequest(): string;
            set networkRequest(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.State">"State"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get state(): number;
            set state(val: number);

            // Methods

            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.Cancel">Cancel()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_ussd_call_cancel_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_ussd_call_cancel_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_cancel(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.Cancel">Cancel()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_ussd_call_cancel_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_ussd_call_cancel_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_cancel(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.Cancel">Cancel()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_ussd_call_cancel_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_ussd_call_cancel_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_cancel(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem3gpp_ussd_call_cancel().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem3gpp_ussd_call_cancel().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_cancel_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.Cancel">Cancel()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem3gpp_ussd_call_cancel() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_cancel_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.Initiate">Initiate()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_ussd_call_initiate_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_ussd_call_initiate_sync() for the synchronous, blocking version of this method.
             * @param arg_command Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_initiate(arg_command: string, cancellable?: Gio.Cancellable | null): Promise<string>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.Initiate">Initiate()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_ussd_call_initiate_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_ussd_call_initiate_sync() for the synchronous, blocking version of this method.
             * @param arg_command Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_initiate(
                arg_command: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.Initiate">Initiate()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_ussd_call_initiate_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_ussd_call_initiate_sync() for the synchronous, blocking version of this method.
             * @param arg_command Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_initiate(
                arg_command: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<string> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem3gpp_ussd_call_initiate().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem3gpp_ussd_call_initiate().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_initiate_finish(res: Gio.AsyncResult): [boolean, string];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.Initiate">Initiate()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem3gpp_ussd_call_initiate() for the asynchronous version of this method.
             * @param arg_command Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_initiate_sync(arg_command: string, cancellable?: Gio.Cancellable | null): [boolean, string];
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.Respond">Respond()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_ussd_call_respond_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_ussd_call_respond_sync() for the synchronous, blocking version of this method.
             * @param arg_response Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_respond(arg_response: string, cancellable?: Gio.Cancellable | null): Promise<string>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.Respond">Respond()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_ussd_call_respond_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_ussd_call_respond_sync() for the synchronous, blocking version of this method.
             * @param arg_response Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_respond(
                arg_response: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.Respond">Respond()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem3gpp_ussd_call_respond_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem3gpp_ussd_call_respond_sync() for the synchronous, blocking version of this method.
             * @param arg_response Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_respond(
                arg_response: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<string> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem3gpp_ussd_call_respond().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem3gpp_ussd_call_respond().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_respond_finish(res: Gio.AsyncResult): [boolean, string];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.Respond">Respond()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem3gpp_ussd_call_respond() for the asynchronous version of this method.
             * @param arg_response Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_respond_sync(arg_response: string, cancellable?: Gio.Cancellable | null): [boolean, string];
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.Cancel">Cancel()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_cancel(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.Initiate">Initiate()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param reply Parameter to return.
             */
            complete_initiate(invocation: Gio.DBusMethodInvocation, reply: string): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.Respond">Respond()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param reply Parameter to return.
             */
            complete_respond(invocation: Gio.DBusMethodInvocation, reply: string): void;

            // Virtual methods

            vfunc_handle_cancel(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_initiate(invocation: Gio.DBusMethodInvocation, arg_command: string): boolean;
            vfunc_handle_respond(invocation: Gio.DBusMethodInvocation, arg_response: string): boolean;
        }

        export const GdbusModem3gppUssd: GdbusModem3gppUssdNamespace & {
            new (): GdbusModem3gppUssd; // This allows `obj instanceof GdbusModem3gppUssd`
        };

        namespace GdbusModemCdma {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                activation_state: number;
                activationState: number;
                cdma1x_registration_state: number;
                cdma1xRegistrationState: number;
                esn: string;
                evdo_registration_state: number;
                evdoRegistrationState: number;
                meid: string;
                nid: number;
                sid: number;
            }
        }

        export interface GdbusModemCdmaNamespace {
            $gtype: GObject.GType<GdbusModemCdma>;
            prototype: GdbusModemCdma;

            /**
             * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-ModemCdma.top_of_page">org.freedesktop.ModemManager1.Modem.ModemCdma</link> D-Bus interface.
             */
            interface_info(): Gio.DBusInterfaceInfo;
            /**
             * Overrides all #GObject properties in the #MmGdbusModemCdma interface for a concrete class.
             * The properties are overridden in the order they are defined.
             * @param klass The class structure for a #GObject derived class.
             * @param property_id_begin The property id to assign to the first overridden property.
             */
            override_properties(klass: typeof GObject.Object, property_id_begin: number): number;
        }
        interface GdbusModemCdma extends GObject.Object {
            // Properties

            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-ModemCdma.ActivationState">"ActivationState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get activation_state(): number;
            set activation_state(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-ModemCdma.ActivationState">"ActivationState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get activationState(): number;
            set activationState(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-ModemCdma.Cdma1xRegistrationState">"Cdma1xRegistrationState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get cdma1x_registration_state(): number;
            set cdma1x_registration_state(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-ModemCdma.Cdma1xRegistrationState">"Cdma1xRegistrationState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get cdma1xRegistrationState(): number;
            set cdma1xRegistrationState(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-ModemCdma.Esn">"Esn"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get esn(): string;
            set esn(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-ModemCdma.EvdoRegistrationState">"EvdoRegistrationState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get evdo_registration_state(): number;
            set evdo_registration_state(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-ModemCdma.EvdoRegistrationState">"EvdoRegistrationState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get evdoRegistrationState(): number;
            set evdoRegistrationState(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-ModemCdma.Meid">"Meid"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get meid(): string;
            set meid(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-ModemCdma.Nid">"Nid"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get nid(): number;
            set nid(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-ModemCdma.Sid">"Sid"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get sid(): number;
            set sid(val: number);

            // Methods

            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-ModemCdma.Activate">Activate()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_cdma_call_activate_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_cdma_call_activate_sync() for the synchronous, blocking version of this method.
             * @param arg_carrier_code Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_activate(arg_carrier_code: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-ModemCdma.Activate">Activate()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_cdma_call_activate_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_cdma_call_activate_sync() for the synchronous, blocking version of this method.
             * @param arg_carrier_code Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_activate(
                arg_carrier_code: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-ModemCdma.Activate">Activate()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_cdma_call_activate_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_cdma_call_activate_sync() for the synchronous, blocking version of this method.
             * @param arg_carrier_code Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_activate(
                arg_carrier_code: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_cdma_call_activate().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_cdma_call_activate().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_activate_finish(res: Gio.AsyncResult): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-ModemCdma.ActivateManual">ActivateManual()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_cdma_call_activate_manual_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_cdma_call_activate_manual_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_activate_manual(arg_properties: GLib.Variant, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-ModemCdma.ActivateManual">ActivateManual()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_cdma_call_activate_manual_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_cdma_call_activate_manual_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_activate_manual(
                arg_properties: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-ModemCdma.ActivateManual">ActivateManual()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_cdma_call_activate_manual_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_cdma_call_activate_manual_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_activate_manual(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_cdma_call_activate_manual().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_cdma_call_activate_manual().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_activate_manual_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-ModemCdma.ActivateManual">ActivateManual()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_cdma_call_activate_manual() for the asynchronous version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_activate_manual_sync(arg_properties: GLib.Variant, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-ModemCdma.Activate">Activate()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_cdma_call_activate() for the asynchronous version of this method.
             * @param arg_carrier_code Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_activate_sync(arg_carrier_code: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-ModemCdma.Activate">Activate()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_activate(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-ModemCdma.ActivateManual">ActivateManual()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_activate_manual(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Emits the <link linkend="gdbus-signal-org-freedesktop-ModemManager1-Modem-ModemCdma.ActivationStateChanged">"ActivationStateChanged"</link> D-Bus signal.
             * @param arg_activation_state Argument to pass with the signal.
             * @param arg_activation_error Argument to pass with the signal.
             * @param arg_status_changes Argument to pass with the signal.
             */
            emit_activation_state_changed(
                arg_activation_state: number,
                arg_activation_error: number,
                arg_status_changes: GLib.Variant,
            ): void;

            // Virtual methods

            vfunc_activation_state_changed(
                arg_activation_state: number,
                arg_activation_error: number,
                arg_status_changes: GLib.Variant,
            ): void;
            vfunc_handle_activate(invocation: Gio.DBusMethodInvocation, arg_carrier_code: string): boolean;
            vfunc_handle_activate_manual(invocation: Gio.DBusMethodInvocation, arg_properties: GLib.Variant): boolean;
        }

        export const GdbusModemCdma: GdbusModemCdmaNamespace & {
            new (): GdbusModemCdma; // This allows `obj instanceof GdbusModemCdma`
        };

        namespace GdbusModemFirmware {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                update_settings: GLib.Variant;
                updateSettings: GLib.Variant;
            }
        }

        export interface GdbusModemFirmwareNamespace {
            $gtype: GObject.GType<GdbusModemFirmware>;
            prototype: GdbusModemFirmware;

            /**
             * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Firmware.top_of_page">org.freedesktop.ModemManager1.Modem.Firmware</link> D-Bus interface.
             */
            interface_info(): Gio.DBusInterfaceInfo;
            /**
             * Overrides all #GObject properties in the #MmGdbusModemFirmware interface for a concrete class.
             * The properties are overridden in the order they are defined.
             * @param klass The class structure for a #GObject derived class.
             * @param property_id_begin The property id to assign to the first overridden property.
             */
            override_properties(klass: typeof GObject.Object, property_id_begin: number): number;
        }
        interface GdbusModemFirmware extends GObject.Object {
            // Properties

            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Firmware.UpdateSettings">"UpdateSettings"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get update_settings(): GLib.Variant;
            set update_settings(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Firmware.UpdateSettings">"UpdateSettings"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get updateSettings(): GLib.Variant;
            set updateSettings(val: GLib.Variant);

            // Methods

            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Firmware.List">List()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_firmware_call_list_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_firmware_call_list_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_list(cancellable?: Gio.Cancellable | null): Promise<[string, GLib.Variant | null]>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Firmware.List">List()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_firmware_call_list_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_firmware_call_list_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_list(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Firmware.List">List()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_firmware_call_list_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_firmware_call_list_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_list(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<[string, GLib.Variant | null]> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_firmware_call_list().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_firmware_call_list().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_list_finish(res: Gio.AsyncResult): [boolean, string, GLib.Variant | null];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Firmware.List">List()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_firmware_call_list() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_list_sync(cancellable?: Gio.Cancellable | null): [boolean, string, GLib.Variant | null];
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Firmware.Select">Select()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_firmware_call_select_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_firmware_call_select_sync() for the synchronous, blocking version of this method.
             * @param arg_uniqueid Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_select(arg_uniqueid: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Firmware.Select">Select()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_firmware_call_select_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_firmware_call_select_sync() for the synchronous, blocking version of this method.
             * @param arg_uniqueid Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_select(
                arg_uniqueid: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Firmware.Select">Select()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_firmware_call_select_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_firmware_call_select_sync() for the synchronous, blocking version of this method.
             * @param arg_uniqueid Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_select(
                arg_uniqueid: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_firmware_call_select().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_firmware_call_select().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_select_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Firmware.Select">Select()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_firmware_call_select() for the asynchronous version of this method.
             * @param arg_uniqueid Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_select_sync(arg_uniqueid: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Firmware.List">List()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param selected Parameter to return.
             * @param installed Parameter to return.
             */
            complete_list(invocation: Gio.DBusMethodInvocation, selected: string, installed: GLib.Variant): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Firmware.Select">Select()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_select(invocation: Gio.DBusMethodInvocation): void;

            // Virtual methods

            vfunc_handle_list(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_select(invocation: Gio.DBusMethodInvocation, arg_uniqueid: string): boolean;
        }

        export const GdbusModemFirmware: GdbusModemFirmwareNamespace & {
            new (): GdbusModemFirmware; // This allows `obj instanceof GdbusModemFirmware`
        };

        namespace GdbusModemLocation {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                assistance_data_servers: string[];
                assistanceDataServers: string[];
                capabilities: number;
                enabled: number;
                gps_refresh_rate: number;
                gpsRefreshRate: number;
                location: GLib.Variant;
                signals_location: boolean;
                signalsLocation: boolean;
                supl_server: string;
                suplServer: string;
                supported_assistance_data: number;
                supportedAssistanceData: number;
            }
        }

        export interface GdbusModemLocationNamespace {
            $gtype: GObject.GType<GdbusModemLocation>;
            prototype: GdbusModemLocation;

            /**
             * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Location.top_of_page">org.freedesktop.ModemManager1.Modem.Location</link> D-Bus interface.
             */
            interface_info(): Gio.DBusInterfaceInfo;
            /**
             * Overrides all #GObject properties in the #MmGdbusModemLocation interface for a concrete class.
             * The properties are overridden in the order they are defined.
             * @param klass The class structure for a #GObject derived class.
             * @param property_id_begin The property id to assign to the first overridden property.
             */
            override_properties(klass: typeof GObject.Object, property_id_begin: number): number;
        }
        interface GdbusModemLocation extends GObject.Object {
            // Properties

            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Location.AssistanceDataServers">"AssistanceDataServers"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get assistance_data_servers(): string[];
            set assistance_data_servers(val: string[]);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Location.AssistanceDataServers">"AssistanceDataServers"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get assistanceDataServers(): string[];
            set assistanceDataServers(val: string[]);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Location.Capabilities">"Capabilities"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get capabilities(): number;
            set capabilities(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Location.Enabled">"Enabled"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get enabled(): number;
            set enabled(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Location.GpsRefreshRate">"GpsRefreshRate"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get gps_refresh_rate(): number;
            set gps_refresh_rate(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Location.GpsRefreshRate">"GpsRefreshRate"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get gpsRefreshRate(): number;
            set gpsRefreshRate(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Location.Location">"Location"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get location(): GLib.Variant;
            set location(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Location.SignalsLocation">"SignalsLocation"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get signals_location(): boolean;
            set signals_location(val: boolean);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Location.SignalsLocation">"SignalsLocation"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get signalsLocation(): boolean;
            set signalsLocation(val: boolean);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Location.SuplServer">"SuplServer"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get supl_server(): string;
            set supl_server(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Location.SuplServer">"SuplServer"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get suplServer(): string;
            set suplServer(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Location.SupportedAssistanceData">"SupportedAssistanceData"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get supported_assistance_data(): number;
            set supported_assistance_data(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Location.SupportedAssistanceData">"SupportedAssistanceData"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get supportedAssistanceData(): number;
            set supportedAssistanceData(val: number);

            // Methods

            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.GetLocation">GetLocation()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_call_get_location_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_call_get_location_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_get_location(cancellable?: Gio.Cancellable | null): Promise<GLib.Variant | null>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.GetLocation">GetLocation()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_call_get_location_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_call_get_location_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_get_location(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.GetLocation">GetLocation()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_call_get_location_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_call_get_location_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_get_location(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<GLib.Variant | null> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_location_call_get_location().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_location_call_get_location().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_get_location_finish(res: Gio.AsyncResult): [boolean, GLib.Variant | null];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.GetLocation">GetLocation()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_location_call_get_location() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_get_location_sync(cancellable?: Gio.Cancellable | null): [boolean, GLib.Variant | null];
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.InjectAssistanceData">InjectAssistanceData()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_call_inject_assistance_data_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_call_inject_assistance_data_sync() for the synchronous, blocking version of this method.
             * @param arg_data Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_inject_assistance_data(arg_data: GLib.Variant, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.InjectAssistanceData">InjectAssistanceData()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_call_inject_assistance_data_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_call_inject_assistance_data_sync() for the synchronous, blocking version of this method.
             * @param arg_data Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_inject_assistance_data(
                arg_data: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.InjectAssistanceData">InjectAssistanceData()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_call_inject_assistance_data_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_call_inject_assistance_data_sync() for the synchronous, blocking version of this method.
             * @param arg_data Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_inject_assistance_data(
                arg_data: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_location_call_inject_assistance_data().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_location_call_inject_assistance_data().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_inject_assistance_data_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.InjectAssistanceData">InjectAssistanceData()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_location_call_inject_assistance_data() for the asynchronous version of this method.
             * @param arg_data Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_inject_assistance_data_sync(arg_data: GLib.Variant, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.SetGpsRefreshRate">SetGpsRefreshRate()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_call_set_gps_refresh_rate_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_call_set_gps_refresh_rate_sync() for the synchronous, blocking version of this method.
             * @param arg_rate Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set_gps_refresh_rate(arg_rate: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.SetGpsRefreshRate">SetGpsRefreshRate()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_call_set_gps_refresh_rate_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_call_set_gps_refresh_rate_sync() for the synchronous, blocking version of this method.
             * @param arg_rate Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_gps_refresh_rate(
                arg_rate: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.SetGpsRefreshRate">SetGpsRefreshRate()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_call_set_gps_refresh_rate_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_call_set_gps_refresh_rate_sync() for the synchronous, blocking version of this method.
             * @param arg_rate Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_gps_refresh_rate(
                arg_rate: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_location_call_set_gps_refresh_rate().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_location_call_set_gps_refresh_rate().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_gps_refresh_rate_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.SetGpsRefreshRate">SetGpsRefreshRate()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_location_call_set_gps_refresh_rate() for the asynchronous version of this method.
             * @param arg_rate Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_gps_refresh_rate_sync(arg_rate: number, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.SetSuplServer">SetSuplServer()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_call_set_supl_server_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_call_set_supl_server_sync() for the synchronous, blocking version of this method.
             * @param arg_supl Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set_supl_server(arg_supl: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.SetSuplServer">SetSuplServer()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_call_set_supl_server_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_call_set_supl_server_sync() for the synchronous, blocking version of this method.
             * @param arg_supl Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_supl_server(
                arg_supl: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.SetSuplServer">SetSuplServer()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_call_set_supl_server_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_call_set_supl_server_sync() for the synchronous, blocking version of this method.
             * @param arg_supl Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_supl_server(
                arg_supl: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_location_call_set_supl_server().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_location_call_set_supl_server().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_supl_server_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.SetSuplServer">SetSuplServer()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_location_call_set_supl_server() for the asynchronous version of this method.
             * @param arg_supl Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_supl_server_sync(arg_supl: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.Setup">Setup()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_call_setup_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_call_setup_sync() for the synchronous, blocking version of this method.
             * @param arg_sources Argument to pass with the method invocation.
             * @param arg_signal_location Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_setup(
                arg_sources: number,
                arg_signal_location: boolean,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.Setup">Setup()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_call_setup_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_call_setup_sync() for the synchronous, blocking version of this method.
             * @param arg_sources Argument to pass with the method invocation.
             * @param arg_signal_location Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_setup(
                arg_sources: number,
                arg_signal_location: boolean,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.Setup">Setup()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_location_call_setup_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_location_call_setup_sync() for the synchronous, blocking version of this method.
             * @param arg_sources Argument to pass with the method invocation.
             * @param arg_signal_location Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_setup(
                arg_sources: number,
                arg_signal_location: boolean,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_location_call_setup().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_location_call_setup().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_setup_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.Setup">Setup()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_location_call_setup() for the asynchronous version of this method.
             * @param arg_sources Argument to pass with the method invocation.
             * @param arg_signal_location Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_setup_sync(
                arg_sources: number,
                arg_signal_location: boolean,
                cancellable?: Gio.Cancellable | null,
            ): boolean;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.GetLocation">GetLocation()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param Location Parameter to return.
             */
            complete_get_location(invocation: Gio.DBusMethodInvocation, Location: GLib.Variant): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.InjectAssistanceData">InjectAssistanceData()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_inject_assistance_data(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.SetGpsRefreshRate">SetGpsRefreshRate()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_set_gps_refresh_rate(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.SetSuplServer">SetSuplServer()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_set_supl_server(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Location.Setup">Setup()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_setup(invocation: Gio.DBusMethodInvocation): void;

            // Virtual methods

            vfunc_handle_get_location(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_inject_assistance_data(invocation: Gio.DBusMethodInvocation, arg_data: GLib.Variant): boolean;
            vfunc_handle_set_gps_refresh_rate(invocation: Gio.DBusMethodInvocation, arg_rate: number): boolean;
            vfunc_handle_set_supl_server(invocation: Gio.DBusMethodInvocation, arg_supl: string): boolean;
            vfunc_handle_setup(
                invocation: Gio.DBusMethodInvocation,
                arg_sources: number,
                arg_signal_location: boolean,
            ): boolean;
        }

        export const GdbusModemLocation: GdbusModemLocationNamespace & {
            new (): GdbusModemLocation; // This allows `obj instanceof GdbusModemLocation`
        };

        namespace GdbusModemMessaging {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                default_storage: number;
                defaultStorage: number;
                messages: string[];
                supported_storages: GLib.Variant;
                supportedStorages: GLib.Variant;
            }
        }

        export interface GdbusModemMessagingNamespace {
            $gtype: GObject.GType<GdbusModemMessaging>;
            prototype: GdbusModemMessaging;

            /**
             * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Messaging.top_of_page">org.freedesktop.ModemManager1.Modem.Messaging</link> D-Bus interface.
             */
            interface_info(): Gio.DBusInterfaceInfo;
            /**
             * Overrides all #GObject properties in the #MmGdbusModemMessaging interface for a concrete class.
             * The properties are overridden in the order they are defined.
             * @param klass The class structure for a #GObject derived class.
             * @param property_id_begin The property id to assign to the first overridden property.
             */
            override_properties(klass: typeof GObject.Object, property_id_begin: number): number;
        }
        interface GdbusModemMessaging extends GObject.Object {
            // Properties

            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Messaging.DefaultStorage">"DefaultStorage"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get default_storage(): number;
            set default_storage(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Messaging.DefaultStorage">"DefaultStorage"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get defaultStorage(): number;
            set defaultStorage(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Messaging.Messages">"Messages"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get messages(): string[];
            set messages(val: string[]);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Messaging.SupportedStorages">"SupportedStorages"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get supported_storages(): GLib.Variant;
            set supported_storages(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Messaging.SupportedStorages">"SupportedStorages"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get supportedStorages(): GLib.Variant;
            set supportedStorages(val: GLib.Variant);

            // Methods

            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Messaging.Create">Create()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_messaging_call_create_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_messaging_call_create_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_create(arg_properties: GLib.Variant, cancellable?: Gio.Cancellable | null): Promise<string>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Messaging.Create">Create()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_messaging_call_create_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_messaging_call_create_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_create(
                arg_properties: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Messaging.Create">Create()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_messaging_call_create_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_messaging_call_create_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_create(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<string> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_messaging_call_create().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_messaging_call_create().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_create_finish(res: Gio.AsyncResult): [boolean, string];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Messaging.Create">Create()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_messaging_call_create() for the asynchronous version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_create_sync(arg_properties: GLib.Variant, cancellable?: Gio.Cancellable | null): [boolean, string];
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Messaging.Delete">Delete()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_messaging_call_delete_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_messaging_call_delete_sync() for the synchronous, blocking version of this method.
             * @param arg_path Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_delete(arg_path: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Messaging.Delete">Delete()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_messaging_call_delete_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_messaging_call_delete_sync() for the synchronous, blocking version of this method.
             * @param arg_path Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_delete(
                arg_path: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Messaging.Delete">Delete()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_messaging_call_delete_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_messaging_call_delete_sync() for the synchronous, blocking version of this method.
             * @param arg_path Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_delete(
                arg_path: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_messaging_call_delete().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_messaging_call_delete().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_delete_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Messaging.Delete">Delete()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_messaging_call_delete() for the asynchronous version of this method.
             * @param arg_path Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_delete_sync(arg_path: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Messaging.List">List()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_messaging_call_list_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_messaging_call_list_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_list(cancellable?: Gio.Cancellable | null): Promise<string[] | null>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Messaging.List">List()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_messaging_call_list_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_messaging_call_list_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_list(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Messaging.List">List()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_messaging_call_list_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_messaging_call_list_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_list(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<string[] | null> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_messaging_call_list().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_messaging_call_list().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_list_finish(res: Gio.AsyncResult): [boolean, string[] | null];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Messaging.List">List()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_messaging_call_list() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_list_sync(cancellable?: Gio.Cancellable | null): [boolean, string[] | null];
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Messaging.Create">Create()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param path Parameter to return.
             */
            complete_create(invocation: Gio.DBusMethodInvocation, path: string): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Messaging.Delete">Delete()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_delete(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Messaging.List">List()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param result Parameter to return.
             */
            complete_list(invocation: Gio.DBusMethodInvocation, result: string): void;
            /**
             * Emits the <link linkend="gdbus-signal-org-freedesktop-ModemManager1-Modem-Messaging.Added">"Added"</link> D-Bus signal.
             * @param arg_path Argument to pass with the signal.
             * @param arg_received Argument to pass with the signal.
             */
            emit_added(arg_path: string, arg_received: boolean): void;
            /**
             * Emits the <link linkend="gdbus-signal-org-freedesktop-ModemManager1-Modem-Messaging.Deleted">"Deleted"</link> D-Bus signal.
             * @param arg_path Argument to pass with the signal.
             */
            emit_deleted(arg_path: string): void;

            // Virtual methods

            vfunc_added(arg_path: string, arg_received: boolean): void;
            vfunc_deleted(arg_path: string): void;
            vfunc_handle_create(invocation: Gio.DBusMethodInvocation, arg_properties: GLib.Variant): boolean;
            vfunc_handle_delete(invocation: Gio.DBusMethodInvocation, arg_path: string): boolean;
            vfunc_handle_list(invocation: Gio.DBusMethodInvocation): boolean;
        }

        export const GdbusModemMessaging: GdbusModemMessagingNamespace & {
            new (): GdbusModemMessaging; // This allows `obj instanceof GdbusModemMessaging`
        };

        namespace GdbusModemOma {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                features: number;
                pending_network_initiated_sessions: GLib.Variant;
                pendingNetworkInitiatedSessions: GLib.Variant;
                session_state: number;
                sessionState: number;
                session_type: number;
                sessionType: number;
            }
        }

        export interface GdbusModemOmaNamespace {
            $gtype: GObject.GType<GdbusModemOma>;
            prototype: GdbusModemOma;

            /**
             * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Oma.top_of_page">org.freedesktop.ModemManager1.Modem.Oma</link> D-Bus interface.
             */
            interface_info(): Gio.DBusInterfaceInfo;
            /**
             * Overrides all #GObject properties in the #MmGdbusModemOma interface for a concrete class.
             * The properties are overridden in the order they are defined.
             * @param klass The class structure for a #GObject derived class.
             * @param property_id_begin The property id to assign to the first overridden property.
             */
            override_properties(klass: typeof GObject.Object, property_id_begin: number): number;
        }
        interface GdbusModemOma extends GObject.Object {
            // Properties

            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Oma.Features">"Features"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get features(): number;
            set features(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Oma.PendingNetworkInitiatedSessions">"PendingNetworkInitiatedSessions"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get pending_network_initiated_sessions(): GLib.Variant;
            set pending_network_initiated_sessions(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Oma.PendingNetworkInitiatedSessions">"PendingNetworkInitiatedSessions"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get pendingNetworkInitiatedSessions(): GLib.Variant;
            set pendingNetworkInitiatedSessions(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Oma.SessionState">"SessionState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get session_state(): number;
            set session_state(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Oma.SessionState">"SessionState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get sessionState(): number;
            set sessionState(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Oma.SessionType">"SessionType"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get session_type(): number;
            set session_type(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Oma.SessionType">"SessionType"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get sessionType(): number;
            set sessionType(val: number);

            // Methods

            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.AcceptNetworkInitiatedSession">AcceptNetworkInitiatedSession()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_oma_call_accept_network_initiated_session_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_oma_call_accept_network_initiated_session_sync() for the synchronous, blocking version of this method.
             * @param arg_session_id Argument to pass with the method invocation.
             * @param arg_accept Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_accept_network_initiated_session(
                arg_session_id: number,
                arg_accept: boolean,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.AcceptNetworkInitiatedSession">AcceptNetworkInitiatedSession()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_oma_call_accept_network_initiated_session_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_oma_call_accept_network_initiated_session_sync() for the synchronous, blocking version of this method.
             * @param arg_session_id Argument to pass with the method invocation.
             * @param arg_accept Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_accept_network_initiated_session(
                arg_session_id: number,
                arg_accept: boolean,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.AcceptNetworkInitiatedSession">AcceptNetworkInitiatedSession()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_oma_call_accept_network_initiated_session_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_oma_call_accept_network_initiated_session_sync() for the synchronous, blocking version of this method.
             * @param arg_session_id Argument to pass with the method invocation.
             * @param arg_accept Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_accept_network_initiated_session(
                arg_session_id: number,
                arg_accept: boolean,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_oma_call_accept_network_initiated_session().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_oma_call_accept_network_initiated_session().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_accept_network_initiated_session_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.AcceptNetworkInitiatedSession">AcceptNetworkInitiatedSession()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_oma_call_accept_network_initiated_session() for the asynchronous version of this method.
             * @param arg_session_id Argument to pass with the method invocation.
             * @param arg_accept Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_accept_network_initiated_session_sync(
                arg_session_id: number,
                arg_accept: boolean,
                cancellable?: Gio.Cancellable | null,
            ): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.CancelSession">CancelSession()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_oma_call_cancel_session_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_oma_call_cancel_session_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_cancel_session(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.CancelSession">CancelSession()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_oma_call_cancel_session_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_oma_call_cancel_session_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_cancel_session(
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.CancelSession">CancelSession()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_oma_call_cancel_session_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_oma_call_cancel_session_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_cancel_session(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_oma_call_cancel_session().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_oma_call_cancel_session().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_cancel_session_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.CancelSession">CancelSession()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_oma_call_cancel_session() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_cancel_session_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.Setup">Setup()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_oma_call_setup_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_oma_call_setup_sync() for the synchronous, blocking version of this method.
             * @param arg_features Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_setup(arg_features: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.Setup">Setup()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_oma_call_setup_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_oma_call_setup_sync() for the synchronous, blocking version of this method.
             * @param arg_features Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_setup(
                arg_features: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.Setup">Setup()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_oma_call_setup_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_oma_call_setup_sync() for the synchronous, blocking version of this method.
             * @param arg_features Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_setup(
                arg_features: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_oma_call_setup().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_oma_call_setup().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_setup_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.Setup">Setup()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_oma_call_setup() for the asynchronous version of this method.
             * @param arg_features Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_setup_sync(arg_features: number, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.StartClientInitiatedSession">StartClientInitiatedSession()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_oma_call_start_client_initiated_session_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_oma_call_start_client_initiated_session_sync() for the synchronous, blocking version of this method.
             * @param arg_session_type Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_start_client_initiated_session(
                arg_session_type: number,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.StartClientInitiatedSession">StartClientInitiatedSession()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_oma_call_start_client_initiated_session_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_oma_call_start_client_initiated_session_sync() for the synchronous, blocking version of this method.
             * @param arg_session_type Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_start_client_initiated_session(
                arg_session_type: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.StartClientInitiatedSession">StartClientInitiatedSession()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_oma_call_start_client_initiated_session_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_oma_call_start_client_initiated_session_sync() for the synchronous, blocking version of this method.
             * @param arg_session_type Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_start_client_initiated_session(
                arg_session_type: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_oma_call_start_client_initiated_session().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_oma_call_start_client_initiated_session().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_start_client_initiated_session_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.StartClientInitiatedSession">StartClientInitiatedSession()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_oma_call_start_client_initiated_session() for the asynchronous version of this method.
             * @param arg_session_type Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_start_client_initiated_session_sync(
                arg_session_type: number,
                cancellable?: Gio.Cancellable | null,
            ): boolean;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.AcceptNetworkInitiatedSession">AcceptNetworkInitiatedSession()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_accept_network_initiated_session(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.CancelSession">CancelSession()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_cancel_session(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.Setup">Setup()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_setup(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Oma.StartClientInitiatedSession">StartClientInitiatedSession()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_start_client_initiated_session(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Emits the <link linkend="gdbus-signal-org-freedesktop-ModemManager1-Modem-Oma.SessionStateChanged">"SessionStateChanged"</link> D-Bus signal.
             * @param arg_old_session_state Argument to pass with the signal.
             * @param arg_new_session_state Argument to pass with the signal.
             * @param arg_session_state_failed_reason Argument to pass with the signal.
             */
            emit_session_state_changed(
                arg_old_session_state: number,
                arg_new_session_state: number,
                arg_session_state_failed_reason: number,
            ): void;

            // Virtual methods

            vfunc_handle_accept_network_initiated_session(
                invocation: Gio.DBusMethodInvocation,
                arg_session_id: number,
                arg_accept: boolean,
            ): boolean;
            vfunc_handle_cancel_session(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_setup(invocation: Gio.DBusMethodInvocation, arg_features: number): boolean;
            vfunc_handle_start_client_initiated_session(
                invocation: Gio.DBusMethodInvocation,
                arg_session_type: number,
            ): boolean;
            vfunc_session_state_changed(
                arg_old_session_state: number,
                arg_new_session_state: number,
                arg_session_state_failed_reason: number,
            ): void;
        }

        export const GdbusModemOma: GdbusModemOmaNamespace & {
            new (): GdbusModemOma; // This allows `obj instanceof GdbusModemOma`
        };

        namespace GdbusModemSar {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                power_level: number;
                powerLevel: number;
                state: boolean;
            }
        }

        export interface GdbusModemSarNamespace {
            $gtype: GObject.GType<GdbusModemSar>;
            prototype: GdbusModemSar;

            /**
             * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Sar.top_of_page">org.freedesktop.ModemManager1.Modem.Sar</link> D-Bus interface.
             */
            interface_info(): Gio.DBusInterfaceInfo;
            /**
             * Overrides all #GObject properties in the #MmGdbusModemSar interface for a concrete class.
             * The properties are overridden in the order they are defined.
             * @param klass The class structure for a #GObject derived class.
             * @param property_id_begin The property id to assign to the first overridden property.
             */
            override_properties(klass: typeof GObject.Object, property_id_begin: number): number;
        }
        interface GdbusModemSar extends GObject.Object {
            // Properties

            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Sar.PowerLevel">"PowerLevel"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get power_level(): number;
            set power_level(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Sar.PowerLevel">"PowerLevel"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get powerLevel(): number;
            set powerLevel(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Sar.State">"State"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get state(): boolean;
            set state(val: boolean);

            // Methods

            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Sar.Enable">Enable()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_sar_call_enable_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_sar_call_enable_sync() for the synchronous, blocking version of this method.
             * @param arg_enable Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_enable(arg_enable: boolean, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Sar.Enable">Enable()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_sar_call_enable_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_sar_call_enable_sync() for the synchronous, blocking version of this method.
             * @param arg_enable Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_enable(
                arg_enable: boolean,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Sar.Enable">Enable()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_sar_call_enable_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_sar_call_enable_sync() for the synchronous, blocking version of this method.
             * @param arg_enable Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_enable(
                arg_enable: boolean,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_sar_call_enable().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_sar_call_enable().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_enable_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Sar.Enable">Enable()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_sar_call_enable() for the asynchronous version of this method.
             * @param arg_enable Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_enable_sync(arg_enable: boolean, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Sar.SetPowerLevel">SetPowerLevel()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_sar_call_set_power_level_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_sar_call_set_power_level_sync() for the synchronous, blocking version of this method.
             * @param arg_level Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set_power_level(arg_level: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Sar.SetPowerLevel">SetPowerLevel()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_sar_call_set_power_level_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_sar_call_set_power_level_sync() for the synchronous, blocking version of this method.
             * @param arg_level Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_power_level(
                arg_level: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Sar.SetPowerLevel">SetPowerLevel()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_sar_call_set_power_level_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_sar_call_set_power_level_sync() for the synchronous, blocking version of this method.
             * @param arg_level Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_power_level(
                arg_level: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_sar_call_set_power_level().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_sar_call_set_power_level().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_power_level_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Sar.SetPowerLevel">SetPowerLevel()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_sar_call_set_power_level() for the asynchronous version of this method.
             * @param arg_level Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_power_level_sync(arg_level: number, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Sar.Enable">Enable()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_enable(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Sar.SetPowerLevel">SetPowerLevel()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_set_power_level(invocation: Gio.DBusMethodInvocation): void;

            // Virtual methods

            vfunc_handle_enable(invocation: Gio.DBusMethodInvocation, arg_enable: boolean): boolean;
            vfunc_handle_set_power_level(invocation: Gio.DBusMethodInvocation, arg_level: number): boolean;
        }

        export const GdbusModemSar: GdbusModemSarNamespace & {
            new (): GdbusModemSar; // This allows `obj instanceof GdbusModemSar`
        };

        namespace GdbusModemSignal {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                cdma: GLib.Variant;
                error_rate_threshold: boolean;
                errorRateThreshold: boolean;
                evdo: GLib.Variant;
                gsm: GLib.Variant;
                lte: GLib.Variant;
                nr5g: GLib.Variant;
                rate: number;
                rssi_threshold: number;
                rssiThreshold: number;
                umts: GLib.Variant;
            }
        }

        export interface GdbusModemSignalNamespace {
            $gtype: GObject.GType<GdbusModemSignal>;
            prototype: GdbusModemSignal;

            /**
             * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Signal.top_of_page">org.freedesktop.ModemManager1.Modem.Signal</link> D-Bus interface.
             */
            interface_info(): Gio.DBusInterfaceInfo;
            /**
             * Overrides all #GObject properties in the #MmGdbusModemSignal interface for a concrete class.
             * The properties are overridden in the order they are defined.
             * @param klass The class structure for a #GObject derived class.
             * @param property_id_begin The property id to assign to the first overridden property.
             */
            override_properties(klass: typeof GObject.Object, property_id_begin: number): number;
        }
        interface GdbusModemSignal extends GObject.Object {
            // Properties

            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Signal.Cdma">"Cdma"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get cdma(): GLib.Variant;
            set cdma(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Signal.ErrorRateThreshold">"ErrorRateThreshold"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get error_rate_threshold(): boolean;
            set error_rate_threshold(val: boolean);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Signal.ErrorRateThreshold">"ErrorRateThreshold"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get errorRateThreshold(): boolean;
            set errorRateThreshold(val: boolean);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Signal.Evdo">"Evdo"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get evdo(): GLib.Variant;
            set evdo(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Signal.Gsm">"Gsm"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get gsm(): GLib.Variant;
            set gsm(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Signal.Lte">"Lte"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get lte(): GLib.Variant;
            set lte(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Signal.Nr5g">"Nr5g"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get nr5g(): GLib.Variant;
            set nr5g(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Signal.Rate">"Rate"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get rate(): number;
            set rate(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Signal.RssiThreshold">"RssiThreshold"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get rssi_threshold(): number;
            set rssi_threshold(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Signal.RssiThreshold">"RssiThreshold"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get rssiThreshold(): number;
            set rssiThreshold(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Signal.Umts">"Umts"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get umts(): GLib.Variant;
            set umts(val: GLib.Variant);

            // Methods

            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Signal.Setup">Setup()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_signal_call_setup_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_signal_call_setup_sync() for the synchronous, blocking version of this method.
             * @param arg_rate Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_setup(arg_rate: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Signal.Setup">Setup()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_signal_call_setup_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_signal_call_setup_sync() for the synchronous, blocking version of this method.
             * @param arg_rate Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_setup(
                arg_rate: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Signal.Setup">Setup()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_signal_call_setup_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_signal_call_setup_sync() for the synchronous, blocking version of this method.
             * @param arg_rate Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_setup(
                arg_rate: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_signal_call_setup().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_signal_call_setup().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_setup_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Signal.Setup">Setup()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_signal_call_setup() for the asynchronous version of this method.
             * @param arg_rate Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_setup_sync(arg_rate: number, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Signal.SetupThresholds">SetupThresholds()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_signal_call_setup_thresholds_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_signal_call_setup_thresholds_sync() for the synchronous, blocking version of this method.
             * @param arg_settings Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_setup_thresholds(arg_settings: GLib.Variant, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Signal.SetupThresholds">SetupThresholds()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_signal_call_setup_thresholds_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_signal_call_setup_thresholds_sync() for the synchronous, blocking version of this method.
             * @param arg_settings Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_setup_thresholds(
                arg_settings: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Signal.SetupThresholds">SetupThresholds()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_signal_call_setup_thresholds_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_signal_call_setup_thresholds_sync() for the synchronous, blocking version of this method.
             * @param arg_settings Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_setup_thresholds(
                arg_settings: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_signal_call_setup_thresholds().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_signal_call_setup_thresholds().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_setup_thresholds_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Signal.SetupThresholds">SetupThresholds()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_signal_call_setup_thresholds() for the asynchronous version of this method.
             * @param arg_settings Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_setup_thresholds_sync(arg_settings: GLib.Variant, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Signal.Setup">Setup()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_setup(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Signal.SetupThresholds">SetupThresholds()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_setup_thresholds(invocation: Gio.DBusMethodInvocation): void;

            // Virtual methods

            vfunc_handle_setup(invocation: Gio.DBusMethodInvocation, arg_rate: number): boolean;
            vfunc_handle_setup_thresholds(invocation: Gio.DBusMethodInvocation, arg_settings: GLib.Variant): boolean;
        }

        export const GdbusModemSignal: GdbusModemSignalNamespace & {
            new (): GdbusModemSignal; // This allows `obj instanceof GdbusModemSignal`
        };

        namespace GdbusModemSimple {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {}
        }

        export interface GdbusModemSimpleNamespace {
            $gtype: GObject.GType<GdbusModemSimple>;
            prototype: GdbusModemSimple;

            /**
             * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Simple.top_of_page">org.freedesktop.ModemManager1.Modem.Simple</link> D-Bus interface.
             */
            interface_info(): Gio.DBusInterfaceInfo;
            /**
             * Overrides all #GObject properties in the #MmGdbusModemSimple interface for a concrete class.
             * The properties are overridden in the order they are defined.
             * @param klass The class structure for a #GObject derived class.
             * @param property_id_begin The property id to assign to the first overridden property.
             */
            override_properties(klass: typeof GObject.Object, property_id_begin: number): number;
        }
        interface GdbusModemSimple extends GObject.Object {
            // Methods

            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Simple.Connect">Connect()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_simple_call_connect_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_simple_call_connect_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_connect(arg_properties: GLib.Variant, cancellable?: Gio.Cancellable | null): Promise<string>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Simple.Connect">Connect()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_simple_call_connect_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_simple_call_connect_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_connect(
                arg_properties: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Simple.Connect">Connect()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_simple_call_connect_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_simple_call_connect_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_connect(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<string> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_simple_call_connect().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_simple_call_connect().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_connect_finish(res: Gio.AsyncResult): [boolean, string];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Simple.Connect">Connect()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_simple_call_connect() for the asynchronous version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_connect_sync(arg_properties: GLib.Variant, cancellable?: Gio.Cancellable | null): [boolean, string];
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Simple.Disconnect">Disconnect()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_simple_call_disconnect_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_simple_call_disconnect_sync() for the synchronous, blocking version of this method.
             * @param arg_bearer Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_disconnect(arg_bearer: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Simple.Disconnect">Disconnect()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_simple_call_disconnect_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_simple_call_disconnect_sync() for the synchronous, blocking version of this method.
             * @param arg_bearer Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_disconnect(
                arg_bearer: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Simple.Disconnect">Disconnect()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_simple_call_disconnect_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_simple_call_disconnect_sync() for the synchronous, blocking version of this method.
             * @param arg_bearer Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_disconnect(
                arg_bearer: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_simple_call_disconnect().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_simple_call_disconnect().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_disconnect_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Simple.Disconnect">Disconnect()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_simple_call_disconnect() for the asynchronous version of this method.
             * @param arg_bearer Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_disconnect_sync(arg_bearer: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Simple.GetStatus">GetStatus()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_simple_call_get_status_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_simple_call_get_status_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_get_status(cancellable?: Gio.Cancellable | null): Promise<GLib.Variant | null>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Simple.GetStatus">GetStatus()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_simple_call_get_status_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_simple_call_get_status_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_get_status(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Simple.GetStatus">GetStatus()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_simple_call_get_status_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_simple_call_get_status_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_get_status(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<GLib.Variant | null> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_simple_call_get_status().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_simple_call_get_status().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_get_status_finish(res: Gio.AsyncResult): [boolean, GLib.Variant | null];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Simple.GetStatus">GetStatus()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_simple_call_get_status() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_get_status_sync(cancellable?: Gio.Cancellable | null): [boolean, GLib.Variant | null];
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Simple.Connect">Connect()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param bearer Parameter to return.
             */
            complete_connect(invocation: Gio.DBusMethodInvocation, bearer: string): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Simple.Disconnect">Disconnect()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_disconnect(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Simple.GetStatus">GetStatus()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param properties Parameter to return.
             */
            complete_get_status(invocation: Gio.DBusMethodInvocation, properties: GLib.Variant): void;

            // Virtual methods

            vfunc_handle_connect(invocation: Gio.DBusMethodInvocation, arg_properties: GLib.Variant): boolean;
            vfunc_handle_disconnect(invocation: Gio.DBusMethodInvocation, arg_bearer: string): boolean;
            vfunc_handle_get_status(invocation: Gio.DBusMethodInvocation): boolean;
        }

        export const GdbusModemSimple: GdbusModemSimpleNamespace & {
            new (): GdbusModemSimple; // This allows `obj instanceof GdbusModemSimple`
        };

        namespace GdbusModemTime {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                network_timezone: GLib.Variant;
                networkTimezone: GLib.Variant;
            }
        }

        export interface GdbusModemTimeNamespace {
            $gtype: GObject.GType<GdbusModemTime>;
            prototype: GdbusModemTime;

            /**
             * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Time.top_of_page">org.freedesktop.ModemManager1.Modem.Time</link> D-Bus interface.
             */
            interface_info(): Gio.DBusInterfaceInfo;
            /**
             * Overrides all #GObject properties in the #MmGdbusModemTime interface for a concrete class.
             * The properties are overridden in the order they are defined.
             * @param klass The class structure for a #GObject derived class.
             * @param property_id_begin The property id to assign to the first overridden property.
             */
            override_properties(klass: typeof GObject.Object, property_id_begin: number): number;
        }
        interface GdbusModemTime extends GObject.Object {
            // Properties

            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Time.NetworkTimezone">"NetworkTimezone"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get network_timezone(): GLib.Variant;
            set network_timezone(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Time.NetworkTimezone">"NetworkTimezone"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get networkTimezone(): GLib.Variant;
            set networkTimezone(val: GLib.Variant);

            // Methods

            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Time.GetNetworkTime">GetNetworkTime()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_time_call_get_network_time_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_time_call_get_network_time_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_get_network_time(cancellable?: Gio.Cancellable | null): Promise<string>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Time.GetNetworkTime">GetNetworkTime()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_time_call_get_network_time_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_time_call_get_network_time_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_get_network_time(
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Time.GetNetworkTime">GetNetworkTime()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_time_call_get_network_time_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_time_call_get_network_time_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_get_network_time(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<string> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_time_call_get_network_time().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_time_call_get_network_time().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_get_network_time_finish(res: Gio.AsyncResult): [boolean, string];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Time.GetNetworkTime">GetNetworkTime()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_time_call_get_network_time() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_get_network_time_sync(cancellable?: Gio.Cancellable | null): [boolean, string];
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Time.GetNetworkTime">GetNetworkTime()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param time Parameter to return.
             */
            complete_get_network_time(invocation: Gio.DBusMethodInvocation, time: string): void;
            /**
             * Emits the <link linkend="gdbus-signal-org-freedesktop-ModemManager1-Modem-Time.NetworkTimeChanged">"NetworkTimeChanged"</link> D-Bus signal.
             * @param arg_time Argument to pass with the signal.
             */
            emit_network_time_changed(arg_time: string): void;

            // Virtual methods

            vfunc_handle_get_network_time(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_network_time_changed(arg_time: string): void;
        }

        export const GdbusModemTime: GdbusModemTimeNamespace & {
            new (): GdbusModemTime; // This allows `obj instanceof GdbusModemTime`
        };

        namespace GdbusModemVoice {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                calls: string[];
                emergency_only: boolean;
                emergencyOnly: boolean;
            }
        }

        export interface GdbusModemVoiceNamespace {
            $gtype: GObject.GType<GdbusModemVoice>;
            prototype: GdbusModemVoice;

            /**
             * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Voice.top_of_page">org.freedesktop.ModemManager1.Modem.Voice</link> D-Bus interface.
             */
            interface_info(): Gio.DBusInterfaceInfo;
            /**
             * Overrides all #GObject properties in the #MmGdbusModemVoice interface for a concrete class.
             * The properties are overridden in the order they are defined.
             * @param klass The class structure for a #GObject derived class.
             * @param property_id_begin The property id to assign to the first overridden property.
             */
            override_properties(klass: typeof GObject.Object, property_id_begin: number): number;
        }
        interface GdbusModemVoice extends GObject.Object {
            // Properties

            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Voice.Calls">"Calls"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get calls(): string[];
            set calls(val: string[]);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Voice.EmergencyOnly">"EmergencyOnly"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get emergency_only(): boolean;
            set emergency_only(val: boolean);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Modem-Voice.EmergencyOnly">"EmergencyOnly"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get emergencyOnly(): boolean;
            set emergencyOnly(val: boolean);

            // Methods

            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.CallWaitingQuery">CallWaitingQuery()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_call_waiting_query_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_call_waiting_query_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_call_waiting_query(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.CallWaitingQuery">CallWaitingQuery()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_call_waiting_query_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_call_waiting_query_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_call_waiting_query(
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.CallWaitingQuery">CallWaitingQuery()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_call_waiting_query_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_call_waiting_query_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_call_waiting_query(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_voice_call_call_waiting_query().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_voice_call_call_waiting_query().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_call_waiting_query_finish(res: Gio.AsyncResult): [boolean, boolean];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.CallWaitingQuery">CallWaitingQuery()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_voice_call_call_waiting_query() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_call_waiting_query_sync(cancellable?: Gio.Cancellable | null): [boolean, boolean];
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.CallWaitingSetup">CallWaitingSetup()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_call_waiting_setup_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_call_waiting_setup_sync() for the synchronous, blocking version of this method.
             * @param arg_enable Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_call_waiting_setup(arg_enable: boolean, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.CallWaitingSetup">CallWaitingSetup()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_call_waiting_setup_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_call_waiting_setup_sync() for the synchronous, blocking version of this method.
             * @param arg_enable Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_call_waiting_setup(
                arg_enable: boolean,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.CallWaitingSetup">CallWaitingSetup()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_call_waiting_setup_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_call_waiting_setup_sync() for the synchronous, blocking version of this method.
             * @param arg_enable Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_call_waiting_setup(
                arg_enable: boolean,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_voice_call_call_waiting_setup().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_voice_call_call_waiting_setup().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_call_waiting_setup_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.CallWaitingSetup">CallWaitingSetup()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_voice_call_call_waiting_setup() for the asynchronous version of this method.
             * @param arg_enable Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_call_waiting_setup_sync(arg_enable: boolean, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.CreateCall">CreateCall()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_create_call_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_create_call_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_create_call(arg_properties: GLib.Variant, cancellable?: Gio.Cancellable | null): Promise<string>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.CreateCall">CreateCall()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_create_call_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_create_call_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_create_call(
                arg_properties: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.CreateCall">CreateCall()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_create_call_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_create_call_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_create_call(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<string> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_voice_call_create_call().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_voice_call_create_call().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_create_call_finish(res: Gio.AsyncResult): [boolean, string];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.CreateCall">CreateCall()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_voice_call_create_call() for the asynchronous version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_create_call_sync(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
            ): [boolean, string];
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.DeleteCall">DeleteCall()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_delete_call_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_delete_call_sync() for the synchronous, blocking version of this method.
             * @param arg_path Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_delete_call(arg_path: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.DeleteCall">DeleteCall()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_delete_call_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_delete_call_sync() for the synchronous, blocking version of this method.
             * @param arg_path Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_delete_call(
                arg_path: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.DeleteCall">DeleteCall()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_delete_call_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_delete_call_sync() for the synchronous, blocking version of this method.
             * @param arg_path Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_delete_call(
                arg_path: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_voice_call_delete_call().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_voice_call_delete_call().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_delete_call_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.DeleteCall">DeleteCall()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_voice_call_delete_call() for the asynchronous version of this method.
             * @param arg_path Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_delete_call_sync(arg_path: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.HangupAll">HangupAll()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_hangup_all_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_hangup_all_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_hangup_all(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.HangupAll">HangupAll()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_hangup_all_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_hangup_all_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_hangup_all(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.HangupAll">HangupAll()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_hangup_all_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_hangup_all_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_hangup_all(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_voice_call_hangup_all().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_voice_call_hangup_all().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_hangup_all_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.HangupAll">HangupAll()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_voice_call_hangup_all() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_hangup_all_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.HangupAndAccept">HangupAndAccept()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_hangup_and_accept_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_hangup_and_accept_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_hangup_and_accept(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.HangupAndAccept">HangupAndAccept()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_hangup_and_accept_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_hangup_and_accept_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_hangup_and_accept(
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.HangupAndAccept">HangupAndAccept()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_hangup_and_accept_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_hangup_and_accept_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_hangup_and_accept(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_voice_call_hangup_and_accept().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_voice_call_hangup_and_accept().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_hangup_and_accept_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.HangupAndAccept">HangupAndAccept()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_voice_call_hangup_and_accept() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_hangup_and_accept_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.HoldAndAccept">HoldAndAccept()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_hold_and_accept_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_hold_and_accept_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_hold_and_accept(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.HoldAndAccept">HoldAndAccept()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_hold_and_accept_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_hold_and_accept_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_hold_and_accept(
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.HoldAndAccept">HoldAndAccept()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_hold_and_accept_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_hold_and_accept_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_hold_and_accept(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_voice_call_hold_and_accept().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_voice_call_hold_and_accept().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_hold_and_accept_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.HoldAndAccept">HoldAndAccept()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_voice_call_hold_and_accept() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_hold_and_accept_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.ListCalls">ListCalls()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_list_calls_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_list_calls_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_list_calls(cancellable?: Gio.Cancellable | null): Promise<string[] | null>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.ListCalls">ListCalls()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_list_calls_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_list_calls_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_list_calls(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.ListCalls">ListCalls()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_list_calls_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_list_calls_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_list_calls(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<string[] | null> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_voice_call_list_calls().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_voice_call_list_calls().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_list_calls_finish(res: Gio.AsyncResult): [boolean, string[] | null];
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.ListCalls">ListCalls()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_voice_call_list_calls() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_list_calls_sync(cancellable?: Gio.Cancellable | null): [boolean, string[] | null];
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.Transfer">Transfer()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_transfer_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_transfer_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_transfer(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.Transfer">Transfer()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_transfer_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_transfer_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_transfer(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.Transfer">Transfer()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_modem_voice_call_transfer_finish() to get the result of the operation.
             *
             * See mm_gdbus_modem_voice_call_transfer_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_transfer(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_modem_voice_call_transfer().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_modem_voice_call_transfer().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_transfer_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.Transfer">Transfer()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_modem_voice_call_transfer() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_transfer_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.CallWaitingQuery">CallWaitingQuery()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param status Parameter to return.
             */
            complete_call_waiting_query(invocation: Gio.DBusMethodInvocation, status: boolean): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.CallWaitingSetup">CallWaitingSetup()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_call_waiting_setup(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.CreateCall">CreateCall()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param path Parameter to return.
             */
            complete_create_call(invocation: Gio.DBusMethodInvocation, path: string): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.DeleteCall">DeleteCall()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_delete_call(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.HangupAll">HangupAll()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_hangup_all(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.HangupAndAccept">HangupAndAccept()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_hangup_and_accept(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.HoldAndAccept">HoldAndAccept()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_hold_and_accept(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.ListCalls">ListCalls()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             * @param result Parameter to return.
             */
            complete_list_calls(invocation: Gio.DBusMethodInvocation, result: string): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Modem-Voice.Transfer">Transfer()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_transfer(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Emits the <link linkend="gdbus-signal-org-freedesktop-ModemManager1-Modem-Voice.CallAdded">"CallAdded"</link> D-Bus signal.
             * @param arg_path Argument to pass with the signal.
             */
            emit_call_added(arg_path: string): void;
            /**
             * Emits the <link linkend="gdbus-signal-org-freedesktop-ModemManager1-Modem-Voice.CallDeleted">"CallDeleted"</link> D-Bus signal.
             * @param arg_path Argument to pass with the signal.
             */
            emit_call_deleted(arg_path: string): void;

            // Virtual methods

            vfunc_call_added(arg_path: string): void;
            vfunc_call_deleted(arg_path: string): void;
            vfunc_handle_call_waiting_query(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_call_waiting_setup(invocation: Gio.DBusMethodInvocation, arg_enable: boolean): boolean;
            vfunc_handle_create_call(invocation: Gio.DBusMethodInvocation, arg_properties: GLib.Variant): boolean;
            vfunc_handle_delete_call(invocation: Gio.DBusMethodInvocation, arg_path: string): boolean;
            vfunc_handle_hangup_all(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_hangup_and_accept(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_hold_and_accept(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_list_calls(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_transfer(invocation: Gio.DBusMethodInvocation): boolean;
        }

        export const GdbusModemVoice: GdbusModemVoiceNamespace & {
            new (): GdbusModemVoice; // This allows `obj instanceof GdbusModemVoice`
        };

        namespace GdbusObject {
            // Constructor properties interface

            interface ConstructorProps extends Gio.DBusObject.ConstructorProps {
                modem: GdbusModem;
                modem_cdma: GdbusModemCdma;
                modemCdma: GdbusModemCdma;
                modem_firmware: GdbusModemFirmware;
                modemFirmware: GdbusModemFirmware;
                modem_location: GdbusModemLocation;
                modemLocation: GdbusModemLocation;
                modem_messaging: GdbusModemMessaging;
                modemMessaging: GdbusModemMessaging;
                modem_oma: GdbusModemOma;
                modemOma: GdbusModemOma;
                modem_sar: GdbusModemSar;
                modemSar: GdbusModemSar;
                modem_signal: GdbusModemSignal;
                modemSignal: GdbusModemSignal;
                modem_simple: GdbusModemSimple;
                modemSimple: GdbusModemSimple;
                modem_time: GdbusModemTime;
                modemTime: GdbusModemTime;
                modem_voice: GdbusModemVoice;
                modemVoice: GdbusModemVoice;
                modem3gpp: GdbusModem3gpp;
                modem3gpp_profile_manager: GdbusModem3gppProfileManager;
                modem3gppProfileManager: GdbusModem3gppProfileManager;
                modem3gpp_ussd: GdbusModem3gppUssd;
                modem3gppUssd: GdbusModem3gppUssd;
            }
        }

        export interface GdbusObjectNamespace {
            $gtype: GObject.GType<GdbusObject>;
            prototype: GdbusObject;
        }
        interface GdbusObject extends Gio.DBusObject {
            // Properties

            /**
             * The #MmGdbusModem instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem.top_of_page">org.freedesktop.ModemManager1.Modem</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem(): GdbusModem;
            set modem(val: GdbusModem);
            /**
             * The #MmGdbusModemCdma instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-ModemCdma.top_of_page">org.freedesktop.ModemManager1.Modem.ModemCdma</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem_cdma(): GdbusModemCdma;
            set modem_cdma(val: GdbusModemCdma);
            /**
             * The #MmGdbusModemCdma instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-ModemCdma.top_of_page">org.freedesktop.ModemManager1.Modem.ModemCdma</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modemCdma(): GdbusModemCdma;
            set modemCdma(val: GdbusModemCdma);
            /**
             * The #MmGdbusModemFirmware instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Firmware.top_of_page">org.freedesktop.ModemManager1.Modem.Firmware</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem_firmware(): GdbusModemFirmware;
            set modem_firmware(val: GdbusModemFirmware);
            /**
             * The #MmGdbusModemFirmware instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Firmware.top_of_page">org.freedesktop.ModemManager1.Modem.Firmware</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modemFirmware(): GdbusModemFirmware;
            set modemFirmware(val: GdbusModemFirmware);
            /**
             * The #MmGdbusModemLocation instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Location.top_of_page">org.freedesktop.ModemManager1.Modem.Location</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem_location(): GdbusModemLocation;
            set modem_location(val: GdbusModemLocation);
            /**
             * The #MmGdbusModemLocation instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Location.top_of_page">org.freedesktop.ModemManager1.Modem.Location</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modemLocation(): GdbusModemLocation;
            set modemLocation(val: GdbusModemLocation);
            /**
             * The #MmGdbusModemMessaging instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Messaging.top_of_page">org.freedesktop.ModemManager1.Modem.Messaging</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem_messaging(): GdbusModemMessaging;
            set modem_messaging(val: GdbusModemMessaging);
            /**
             * The #MmGdbusModemMessaging instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Messaging.top_of_page">org.freedesktop.ModemManager1.Modem.Messaging</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modemMessaging(): GdbusModemMessaging;
            set modemMessaging(val: GdbusModemMessaging);
            /**
             * The #MmGdbusModemOma instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Oma.top_of_page">org.freedesktop.ModemManager1.Modem.Oma</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem_oma(): GdbusModemOma;
            set modem_oma(val: GdbusModemOma);
            /**
             * The #MmGdbusModemOma instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Oma.top_of_page">org.freedesktop.ModemManager1.Modem.Oma</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modemOma(): GdbusModemOma;
            set modemOma(val: GdbusModemOma);
            /**
             * The #MmGdbusModemSar instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Sar.top_of_page">org.freedesktop.ModemManager1.Modem.Sar</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem_sar(): GdbusModemSar;
            set modem_sar(val: GdbusModemSar);
            /**
             * The #MmGdbusModemSar instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Sar.top_of_page">org.freedesktop.ModemManager1.Modem.Sar</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modemSar(): GdbusModemSar;
            set modemSar(val: GdbusModemSar);
            /**
             * The #MmGdbusModemSignal instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Signal.top_of_page">org.freedesktop.ModemManager1.Modem.Signal</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem_signal(): GdbusModemSignal;
            set modem_signal(val: GdbusModemSignal);
            /**
             * The #MmGdbusModemSignal instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Signal.top_of_page">org.freedesktop.ModemManager1.Modem.Signal</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modemSignal(): GdbusModemSignal;
            set modemSignal(val: GdbusModemSignal);
            /**
             * The #MmGdbusModemSimple instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Simple.top_of_page">org.freedesktop.ModemManager1.Modem.Simple</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem_simple(): GdbusModemSimple;
            set modem_simple(val: GdbusModemSimple);
            /**
             * The #MmGdbusModemSimple instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Simple.top_of_page">org.freedesktop.ModemManager1.Modem.Simple</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modemSimple(): GdbusModemSimple;
            set modemSimple(val: GdbusModemSimple);
            /**
             * The #MmGdbusModemTime instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Time.top_of_page">org.freedesktop.ModemManager1.Modem.Time</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem_time(): GdbusModemTime;
            set modem_time(val: GdbusModemTime);
            /**
             * The #MmGdbusModemTime instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Time.top_of_page">org.freedesktop.ModemManager1.Modem.Time</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modemTime(): GdbusModemTime;
            set modemTime(val: GdbusModemTime);
            /**
             * The #MmGdbusModemVoice instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Voice.top_of_page">org.freedesktop.ModemManager1.Modem.Voice</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem_voice(): GdbusModemVoice;
            set modem_voice(val: GdbusModemVoice);
            /**
             * The #MmGdbusModemVoice instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Voice.top_of_page">org.freedesktop.ModemManager1.Modem.Voice</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modemVoice(): GdbusModemVoice;
            set modemVoice(val: GdbusModemVoice);
            /**
             * The #MmGdbusModem3gpp instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Modem3gpp.top_of_page">org.freedesktop.ModemManager1.Modem.Modem3gpp</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem3gpp(): GdbusModem3gpp;
            set modem3gpp(val: GdbusModem3gpp);
            /**
             * The #MmGdbusModem3gppProfileManager instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.top_of_page">org.freedesktop.ModemManager1.Modem.Modem3gpp.ProfileManager</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem3gpp_profile_manager(): GdbusModem3gppProfileManager;
            set modem3gpp_profile_manager(val: GdbusModem3gppProfileManager);
            /**
             * The #MmGdbusModem3gppProfileManager instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.top_of_page">org.freedesktop.ModemManager1.Modem.Modem3gpp.ProfileManager</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem3gppProfileManager(): GdbusModem3gppProfileManager;
            set modem3gppProfileManager(val: GdbusModem3gppProfileManager);
            /**
             * The #MmGdbusModem3gppUssd instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.top_of_page">org.freedesktop.ModemManager1.Modem.Modem3gpp.Ussd</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem3gpp_ussd(): GdbusModem3gppUssd;
            set modem3gpp_ussd(val: GdbusModem3gppUssd);
            /**
             * The #MmGdbusModem3gppUssd instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.top_of_page">org.freedesktop.ModemManager1.Modem.Modem3gpp.Ussd</link>, if any.
             *
             * Connect to the #GObject::notify signal to get informed of property changes.
             */
            get modem3gppUssd(): GdbusModem3gppUssd;
            set modem3gppUssd(val: GdbusModem3gppUssd);

            // Methods

            /**
             * Gets the #MmGdbusModem instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem.top_of_page">org.freedesktop.ModemManager1.Modem</link> on `object,` if any.
             * @returns A #MmGdbusModem that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
             */
            get_modem(): GdbusModem | null;
            /**
             * Gets the #MmGdbusModem3gpp instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Modem3gpp.top_of_page">org.freedesktop.ModemManager1.Modem.Modem3gpp</link> on `object,` if any.
             * @returns A #MmGdbusModem3gpp that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
             */
            get_modem3gpp(): GdbusModem3gpp | null;
            /**
             * Gets the #MmGdbusModem3gppProfileManager instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Modem3gpp-ProfileManager.top_of_page">org.freedesktop.ModemManager1.Modem.Modem3gpp.ProfileManager</link> on `object,` if any.
             * @returns A #MmGdbusModem3gppProfileManager that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
             */
            get_modem3gpp_profile_manager(): GdbusModem3gppProfileManager | null;
            /**
             * Gets the #MmGdbusModem3gppUssd instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Modem3gpp-Ussd.top_of_page">org.freedesktop.ModemManager1.Modem.Modem3gpp.Ussd</link> on `object,` if any.
             * @returns A #MmGdbusModem3gppUssd that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
             */
            get_modem3gpp_ussd(): GdbusModem3gppUssd | null;
            /**
             * Gets the #MmGdbusModemCdma instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-ModemCdma.top_of_page">org.freedesktop.ModemManager1.Modem.ModemCdma</link> on `object,` if any.
             * @returns A #MmGdbusModemCdma that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
             */
            get_modem_cdma(): GdbusModemCdma | null;
            /**
             * Gets the #MmGdbusModemFirmware instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Firmware.top_of_page">org.freedesktop.ModemManager1.Modem.Firmware</link> on `object,` if any.
             * @returns A #MmGdbusModemFirmware that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
             */
            get_modem_firmware(): GdbusModemFirmware | null;
            /**
             * Gets the #MmGdbusModemLocation instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Location.top_of_page">org.freedesktop.ModemManager1.Modem.Location</link> on `object,` if any.
             * @returns A #MmGdbusModemLocation that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
             */
            get_modem_location(): GdbusModemLocation | null;
            /**
             * Gets the #MmGdbusModemMessaging instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Messaging.top_of_page">org.freedesktop.ModemManager1.Modem.Messaging</link> on `object,` if any.
             * @returns A #MmGdbusModemMessaging that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
             */
            get_modem_messaging(): GdbusModemMessaging | null;
            /**
             * Gets the #MmGdbusModemOma instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Oma.top_of_page">org.freedesktop.ModemManager1.Modem.Oma</link> on `object,` if any.
             * @returns A #MmGdbusModemOma that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
             */
            get_modem_oma(): GdbusModemOma | null;
            /**
             * Gets the #MmGdbusModemSar instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Sar.top_of_page">org.freedesktop.ModemManager1.Modem.Sar</link> on `object,` if any.
             * @returns A #MmGdbusModemSar that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
             */
            get_modem_sar(): GdbusModemSar | null;
            /**
             * Gets the #MmGdbusModemSignal instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Signal.top_of_page">org.freedesktop.ModemManager1.Modem.Signal</link> on `object,` if any.
             * @returns A #MmGdbusModemSignal that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
             */
            get_modem_signal(): GdbusModemSignal | null;
            /**
             * Gets the #MmGdbusModemSimple instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Simple.top_of_page">org.freedesktop.ModemManager1.Modem.Simple</link> on `object,` if any.
             * @returns A #MmGdbusModemSimple that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
             */
            get_modem_simple(): GdbusModemSimple | null;
            /**
             * Gets the #MmGdbusModemTime instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Time.top_of_page">org.freedesktop.ModemManager1.Modem.Time</link> on `object,` if any.
             * @returns A #MmGdbusModemTime that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
             */
            get_modem_time(): GdbusModemTime | null;
            /**
             * Gets the #MmGdbusModemVoice instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Modem-Voice.top_of_page">org.freedesktop.ModemManager1.Modem.Voice</link> on `object,` if any.
             * @returns A #MmGdbusModemVoice that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
             */
            get_modem_voice(): GdbusModemVoice | null;
        }

        export const GdbusObject: GdbusObjectNamespace & {
            new (): GdbusObject; // This allows `obj instanceof GdbusObject`
        };

        namespace GdbusOrgFreedesktopModemManager1 {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                version: string;
            }
        }

        export interface GdbusOrgFreedesktopModemManager1Namespace {
            $gtype: GObject.GType<GdbusOrgFreedesktopModemManager1>;
            prototype: GdbusOrgFreedesktopModemManager1;

            /**
             * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-ModemManager1.top_of_page">org.freedesktop.ModemManager1</link> D-Bus interface.
             */
            interface_info(): Gio.DBusInterfaceInfo;
            /**
             * Overrides all #GObject properties in the #MmGdbusOrgFreedesktopModemManager1 interface for a concrete class.
             * The properties are overridden in the order they are defined.
             * @param klass The class structure for a #GObject derived class.
             * @param property_id_begin The property id to assign to the first overridden property.
             */
            override_properties(klass: typeof GObject.Object, property_id_begin: number): number;
        }
        interface GdbusOrgFreedesktopModemManager1 extends GObject.Object {
            // Properties

            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1.Version">"Version"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get version(): string;
            set version(val: string);

            // Methods

            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1.InhibitDevice">InhibitDevice()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_org_freedesktop_modem_manager1_call_inhibit_device_finish() to get the result of the operation.
             *
             * See mm_gdbus_org_freedesktop_modem_manager1_call_inhibit_device_sync() for the synchronous, blocking version of this method.
             * @param arg_uid Argument to pass with the method invocation.
             * @param arg_inhibit Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_inhibit_device(
                arg_uid: string,
                arg_inhibit: boolean,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1.InhibitDevice">InhibitDevice()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_org_freedesktop_modem_manager1_call_inhibit_device_finish() to get the result of the operation.
             *
             * See mm_gdbus_org_freedesktop_modem_manager1_call_inhibit_device_sync() for the synchronous, blocking version of this method.
             * @param arg_uid Argument to pass with the method invocation.
             * @param arg_inhibit Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_inhibit_device(
                arg_uid: string,
                arg_inhibit: boolean,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1.InhibitDevice">InhibitDevice()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_org_freedesktop_modem_manager1_call_inhibit_device_finish() to get the result of the operation.
             *
             * See mm_gdbus_org_freedesktop_modem_manager1_call_inhibit_device_sync() for the synchronous, blocking version of this method.
             * @param arg_uid Argument to pass with the method invocation.
             * @param arg_inhibit Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_inhibit_device(
                arg_uid: string,
                arg_inhibit: boolean,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_org_freedesktop_modem_manager1_call_inhibit_device().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_org_freedesktop_modem_manager1_call_inhibit_device().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_inhibit_device_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1.InhibitDevice">InhibitDevice()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_org_freedesktop_modem_manager1_call_inhibit_device() for the asynchronous version of this method.
             * @param arg_uid Argument to pass with the method invocation.
             * @param arg_inhibit Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_inhibit_device_sync(
                arg_uid: string,
                arg_inhibit: boolean,
                cancellable?: Gio.Cancellable | null,
            ): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1.ReportKernelEvent">ReportKernelEvent()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_org_freedesktop_modem_manager1_call_report_kernel_event_finish() to get the result of the operation.
             *
             * See mm_gdbus_org_freedesktop_modem_manager1_call_report_kernel_event_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_report_kernel_event(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1.ReportKernelEvent">ReportKernelEvent()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_org_freedesktop_modem_manager1_call_report_kernel_event_finish() to get the result of the operation.
             *
             * See mm_gdbus_org_freedesktop_modem_manager1_call_report_kernel_event_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_report_kernel_event(
                arg_properties: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1.ReportKernelEvent">ReportKernelEvent()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_org_freedesktop_modem_manager1_call_report_kernel_event_finish() to get the result of the operation.
             *
             * See mm_gdbus_org_freedesktop_modem_manager1_call_report_kernel_event_sync() for the synchronous, blocking version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_report_kernel_event(
                arg_properties: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_org_freedesktop_modem_manager1_call_report_kernel_event().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_org_freedesktop_modem_manager1_call_report_kernel_event().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_report_kernel_event_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1.ReportKernelEvent">ReportKernelEvent()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_org_freedesktop_modem_manager1_call_report_kernel_event() for the asynchronous version of this method.
             * @param arg_properties Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_report_kernel_event_sync(arg_properties: GLib.Variant, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1.ScanDevices">ScanDevices()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_org_freedesktop_modem_manager1_call_scan_devices_finish() to get the result of the operation.
             *
             * See mm_gdbus_org_freedesktop_modem_manager1_call_scan_devices_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_scan_devices(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1.ScanDevices">ScanDevices()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_org_freedesktop_modem_manager1_call_scan_devices_finish() to get the result of the operation.
             *
             * See mm_gdbus_org_freedesktop_modem_manager1_call_scan_devices_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_scan_devices(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1.ScanDevices">ScanDevices()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_org_freedesktop_modem_manager1_call_scan_devices_finish() to get the result of the operation.
             *
             * See mm_gdbus_org_freedesktop_modem_manager1_call_scan_devices_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_scan_devices(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_org_freedesktop_modem_manager1_call_scan_devices().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_org_freedesktop_modem_manager1_call_scan_devices().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_scan_devices_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1.ScanDevices">ScanDevices()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_org_freedesktop_modem_manager1_call_scan_devices() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_scan_devices_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1.SetLogging">SetLogging()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_org_freedesktop_modem_manager1_call_set_logging_finish() to get the result of the operation.
             *
             * See mm_gdbus_org_freedesktop_modem_manager1_call_set_logging_sync() for the synchronous, blocking version of this method.
             * @param arg_level Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set_logging(arg_level: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1.SetLogging">SetLogging()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_org_freedesktop_modem_manager1_call_set_logging_finish() to get the result of the operation.
             *
             * See mm_gdbus_org_freedesktop_modem_manager1_call_set_logging_sync() for the synchronous, blocking version of this method.
             * @param arg_level Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_logging(
                arg_level: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1.SetLogging">SetLogging()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_org_freedesktop_modem_manager1_call_set_logging_finish() to get the result of the operation.
             *
             * See mm_gdbus_org_freedesktop_modem_manager1_call_set_logging_sync() for the synchronous, blocking version of this method.
             * @param arg_level Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_logging(
                arg_level: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_org_freedesktop_modem_manager1_call_set_logging().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_org_freedesktop_modem_manager1_call_set_logging().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_logging_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1.SetLogging">SetLogging()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_org_freedesktop_modem_manager1_call_set_logging() for the asynchronous version of this method.
             * @param arg_level Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_logging_sync(arg_level: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1.InhibitDevice">InhibitDevice()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_inhibit_device(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1.ReportKernelEvent">ReportKernelEvent()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_report_kernel_event(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1.ScanDevices">ScanDevices()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_scan_devices(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1.SetLogging">SetLogging()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_set_logging(invocation: Gio.DBusMethodInvocation): void;

            // Virtual methods

            vfunc_handle_inhibit_device(
                invocation: Gio.DBusMethodInvocation,
                arg_uid: string,
                arg_inhibit: boolean,
            ): boolean;
            vfunc_handle_report_kernel_event(
                invocation: Gio.DBusMethodInvocation,
                arg_properties: GLib.Variant,
            ): boolean;
            vfunc_handle_scan_devices(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_set_logging(invocation: Gio.DBusMethodInvocation, arg_level: string): boolean;
        }

        export const GdbusOrgFreedesktopModemManager1: GdbusOrgFreedesktopModemManager1Namespace & {
            new (): GdbusOrgFreedesktopModemManager1; // This allows `obj instanceof GdbusOrgFreedesktopModemManager1`
        };

        namespace GdbusSim {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                active: boolean;
                eid: string;
                emergency_numbers: string[];
                emergencyNumbers: string[];
                esim_status: number;
                esimStatus: number;
                gid1: GLib.Variant;
                gid2: GLib.Variant;
                imsi: string;
                operator_identifier: string;
                operatorIdentifier: string;
                operator_name: string;
                operatorName: string;
                preferred_networks: GLib.Variant;
                preferredNetworks: GLib.Variant;
                removability: number;
                sim_identifier: string;
                simIdentifier: string;
                sim_type: number;
                simType: number;
            }
        }

        export interface GdbusSimNamespace {
            $gtype: GObject.GType<GdbusSim>;
            prototype: GdbusSim;

            /**
             * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Sim.top_of_page">org.freedesktop.ModemManager1.Sim</link> D-Bus interface.
             */
            interface_info(): Gio.DBusInterfaceInfo;
            /**
             * Overrides all #GObject properties in the #MmGdbusSim interface for a concrete class.
             * The properties are overridden in the order they are defined.
             * @param klass The class structure for a #GObject derived class.
             * @param property_id_begin The property id to assign to the first overridden property.
             */
            override_properties(klass: typeof GObject.Object, property_id_begin: number): number;
        }
        interface GdbusSim extends GObject.Object {
            // Properties

            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.Active">"Active"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get active(): boolean;
            set active(val: boolean);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.Eid">"Eid"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get eid(): string;
            set eid(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.EmergencyNumbers">"EmergencyNumbers"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get emergency_numbers(): string[];
            set emergency_numbers(val: string[]);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.EmergencyNumbers">"EmergencyNumbers"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get emergencyNumbers(): string[];
            set emergencyNumbers(val: string[]);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.EsimStatus">"EsimStatus"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get esim_status(): number;
            set esim_status(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.EsimStatus">"EsimStatus"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get esimStatus(): number;
            set esimStatus(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.Gid1">"Gid1"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get gid1(): GLib.Variant;
            set gid1(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.Gid2">"Gid2"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get gid2(): GLib.Variant;
            set gid2(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.Imsi">"Imsi"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get imsi(): string;
            set imsi(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.OperatorIdentifier">"OperatorIdentifier"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get operator_identifier(): string;
            set operator_identifier(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.OperatorIdentifier">"OperatorIdentifier"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get operatorIdentifier(): string;
            set operatorIdentifier(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.OperatorName">"OperatorName"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get operator_name(): string;
            set operator_name(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.OperatorName">"OperatorName"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get operatorName(): string;
            set operatorName(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.PreferredNetworks">"PreferredNetworks"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get preferred_networks(): GLib.Variant;
            set preferred_networks(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.PreferredNetworks">"PreferredNetworks"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get preferredNetworks(): GLib.Variant;
            set preferredNetworks(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.Removability">"Removability"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get removability(): number;
            set removability(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.SimIdentifier">"SimIdentifier"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get sim_identifier(): string;
            set sim_identifier(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.SimIdentifier">"SimIdentifier"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get simIdentifier(): string;
            set simIdentifier(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.SimType">"SimType"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get sim_type(): number;
            set sim_type(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sim.SimType">"SimType"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get simType(): number;
            set simType(val: number);

            // Methods

            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.ChangePin">ChangePin()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_call_change_pin_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_call_change_pin_sync() for the synchronous, blocking version of this method.
             * @param arg_old_pin Argument to pass with the method invocation.
             * @param arg_new_pin Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_change_pin(
                arg_old_pin: string,
                arg_new_pin: string,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.ChangePin">ChangePin()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_call_change_pin_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_call_change_pin_sync() for the synchronous, blocking version of this method.
             * @param arg_old_pin Argument to pass with the method invocation.
             * @param arg_new_pin Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_change_pin(
                arg_old_pin: string,
                arg_new_pin: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.ChangePin">ChangePin()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_call_change_pin_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_call_change_pin_sync() for the synchronous, blocking version of this method.
             * @param arg_old_pin Argument to pass with the method invocation.
             * @param arg_new_pin Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_change_pin(
                arg_old_pin: string,
                arg_new_pin: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_sim_call_change_pin().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_sim_call_change_pin().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_change_pin_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.ChangePin">ChangePin()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_sim_call_change_pin() for the asynchronous version of this method.
             * @param arg_old_pin Argument to pass with the method invocation.
             * @param arg_new_pin Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_change_pin_sync(
                arg_old_pin: string,
                arg_new_pin: string,
                cancellable?: Gio.Cancellable | null,
            ): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.EnablePin">EnablePin()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_call_enable_pin_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_call_enable_pin_sync() for the synchronous, blocking version of this method.
             * @param arg_pin Argument to pass with the method invocation.
             * @param arg_enabled Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_enable_pin(
                arg_pin: string,
                arg_enabled: boolean,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.EnablePin">EnablePin()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_call_enable_pin_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_call_enable_pin_sync() for the synchronous, blocking version of this method.
             * @param arg_pin Argument to pass with the method invocation.
             * @param arg_enabled Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_enable_pin(
                arg_pin: string,
                arg_enabled: boolean,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.EnablePin">EnablePin()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_call_enable_pin_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_call_enable_pin_sync() for the synchronous, blocking version of this method.
             * @param arg_pin Argument to pass with the method invocation.
             * @param arg_enabled Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_enable_pin(
                arg_pin: string,
                arg_enabled: boolean,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_sim_call_enable_pin().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_sim_call_enable_pin().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_enable_pin_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.EnablePin">EnablePin()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_sim_call_enable_pin() for the asynchronous version of this method.
             * @param arg_pin Argument to pass with the method invocation.
             * @param arg_enabled Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_enable_pin_sync(arg_pin: string, arg_enabled: boolean, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.SendPin">SendPin()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_call_send_pin_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_call_send_pin_sync() for the synchronous, blocking version of this method.
             * @param arg_pin Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_send_pin(arg_pin: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.SendPin">SendPin()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_call_send_pin_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_call_send_pin_sync() for the synchronous, blocking version of this method.
             * @param arg_pin Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_send_pin(
                arg_pin: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.SendPin">SendPin()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_call_send_pin_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_call_send_pin_sync() for the synchronous, blocking version of this method.
             * @param arg_pin Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_send_pin(
                arg_pin: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_sim_call_send_pin().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_sim_call_send_pin().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_send_pin_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.SendPin">SendPin()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_sim_call_send_pin() for the asynchronous version of this method.
             * @param arg_pin Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_send_pin_sync(arg_pin: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.SendPuk">SendPuk()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_call_send_puk_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_call_send_puk_sync() for the synchronous, blocking version of this method.
             * @param arg_puk Argument to pass with the method invocation.
             * @param arg_pin Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_send_puk(arg_puk: string, arg_pin: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.SendPuk">SendPuk()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_call_send_puk_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_call_send_puk_sync() for the synchronous, blocking version of this method.
             * @param arg_puk Argument to pass with the method invocation.
             * @param arg_pin Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_send_puk(
                arg_puk: string,
                arg_pin: string,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.SendPuk">SendPuk()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_call_send_puk_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_call_send_puk_sync() for the synchronous, blocking version of this method.
             * @param arg_puk Argument to pass with the method invocation.
             * @param arg_pin Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_send_puk(
                arg_puk: string,
                arg_pin: string,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_sim_call_send_puk().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_sim_call_send_puk().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_send_puk_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.SendPuk">SendPuk()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_sim_call_send_puk() for the asynchronous version of this method.
             * @param arg_puk Argument to pass with the method invocation.
             * @param arg_pin Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_send_puk_sync(arg_puk: string, arg_pin: string, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.SetPreferredNetworks">SetPreferredNetworks()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_call_set_preferred_networks_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_call_set_preferred_networks_sync() for the synchronous, blocking version of this method.
             * @param arg_preferred_networks Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_set_preferred_networks(
                arg_preferred_networks: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
            ): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.SetPreferredNetworks">SetPreferredNetworks()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_call_set_preferred_networks_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_call_set_preferred_networks_sync() for the synchronous, blocking version of this method.
             * @param arg_preferred_networks Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_preferred_networks(
                arg_preferred_networks: GLib.Variant,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.SetPreferredNetworks">SetPreferredNetworks()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sim_call_set_preferred_networks_finish() to get the result of the operation.
             *
             * See mm_gdbus_sim_call_set_preferred_networks_sync() for the synchronous, blocking version of this method.
             * @param arg_preferred_networks Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_set_preferred_networks(
                arg_preferred_networks: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_sim_call_set_preferred_networks().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_sim_call_set_preferred_networks().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_preferred_networks_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.SetPreferredNetworks">SetPreferredNetworks()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_sim_call_set_preferred_networks() for the asynchronous version of this method.
             * @param arg_preferred_networks Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_set_preferred_networks_sync(
                arg_preferred_networks: GLib.Variant,
                cancellable?: Gio.Cancellable | null,
            ): boolean;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.ChangePin">ChangePin()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_change_pin(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.EnablePin">EnablePin()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_enable_pin(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.SendPin">SendPin()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_send_pin(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.SendPuk">SendPuk()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_send_puk(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sim.SetPreferredNetworks">SetPreferredNetworks()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_set_preferred_networks(invocation: Gio.DBusMethodInvocation): void;

            // Virtual methods

            vfunc_handle_change_pin(
                invocation: Gio.DBusMethodInvocation,
                arg_old_pin: string,
                arg_new_pin: string,
            ): boolean;
            vfunc_handle_enable_pin(
                invocation: Gio.DBusMethodInvocation,
                arg_pin: string,
                arg_enabled: boolean,
            ): boolean;
            vfunc_handle_send_pin(invocation: Gio.DBusMethodInvocation, arg_pin: string): boolean;
            vfunc_handle_send_puk(invocation: Gio.DBusMethodInvocation, arg_puk: string, arg_pin: string): boolean;
            vfunc_handle_set_preferred_networks(
                invocation: Gio.DBusMethodInvocation,
                arg_preferred_networks: GLib.Variant,
            ): boolean;
        }

        export const GdbusSim: GdbusSimNamespace & {
            new (): GdbusSim; // This allows `obj instanceof GdbusSim`
        };

        namespace GdbusSms {
            // Constructor properties interface

            interface ConstructorProps extends GObject.Object.ConstructorProps {
                class: number;
                data: GLib.Variant;
                delivery_report_request: boolean;
                deliveryReportRequest: boolean;
                delivery_state: number;
                deliveryState: number;
                discharge_timestamp: string;
                dischargeTimestamp: string;
                message_reference: number;
                messageReference: number;
                number: string;
                pdu_type: number;
                pduType: number;
                service_category: number;
                serviceCategory: number;
                smsc: string;
                state: number;
                storage: number;
                teleservice_id: number;
                teleserviceId: number;
                text: string;
                timestamp: string;
                validity: GLib.Variant;
            }
        }

        export interface GdbusSmsNamespace {
            $gtype: GObject.GType<GdbusSms>;
            prototype: GdbusSms;

            /**
             * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-ModemManager1-Sms.top_of_page">org.freedesktop.ModemManager1.Sms</link> D-Bus interface.
             */
            interface_info(): Gio.DBusInterfaceInfo;
            /**
             * Overrides all #GObject properties in the #MmGdbusSms interface for a concrete class.
             * The properties are overridden in the order they are defined.
             * @param klass The class structure for a #GObject derived class.
             * @param property_id_begin The property id to assign to the first overridden property.
             */
            override_properties(klass: typeof GObject.Object, property_id_begin: number): number;
        }
        interface GdbusSms extends GObject.Object {
            // Properties

            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.Class">"Class"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get 'class'(): number;
            set 'class'(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.Data">"Data"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get data(): GLib.Variant;
            set data(val: GLib.Variant);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.DeliveryReportRequest">"DeliveryReportRequest"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get delivery_report_request(): boolean;
            set delivery_report_request(val: boolean);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.DeliveryReportRequest">"DeliveryReportRequest"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get deliveryReportRequest(): boolean;
            set deliveryReportRequest(val: boolean);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.DeliveryState">"DeliveryState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get delivery_state(): number;
            set delivery_state(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.DeliveryState">"DeliveryState"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get deliveryState(): number;
            set deliveryState(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.DischargeTimestamp">"DischargeTimestamp"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get discharge_timestamp(): string;
            set discharge_timestamp(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.DischargeTimestamp">"DischargeTimestamp"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get dischargeTimestamp(): string;
            set dischargeTimestamp(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.MessageReference">"MessageReference"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get message_reference(): number;
            set message_reference(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.MessageReference">"MessageReference"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get messageReference(): number;
            set messageReference(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.Number">"Number"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get number(): string;
            set number(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.PduType">"PduType"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get pdu_type(): number;
            set pdu_type(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.PduType">"PduType"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get pduType(): number;
            set pduType(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.ServiceCategory">"ServiceCategory"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get service_category(): number;
            set service_category(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.ServiceCategory">"ServiceCategory"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get serviceCategory(): number;
            set serviceCategory(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.SMSC">"SMSC"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get smsc(): string;
            set smsc(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.State">"State"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get state(): number;
            set state(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.Storage">"Storage"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get storage(): number;
            set storage(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.TeleserviceId">"TeleserviceId"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get teleservice_id(): number;
            set teleservice_id(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.TeleserviceId">"TeleserviceId"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get teleserviceId(): number;
            set teleserviceId(val: number);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.Text">"Text"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get text(): string;
            set text(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.Timestamp">"Timestamp"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get timestamp(): string;
            set timestamp(val: string);
            /**
             * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-ModemManager1-Sms.Validity">"Validity"</link>.
             *
             * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
             */
            get validity(): GLib.Variant;
            set validity(val: GLib.Variant);

            // Methods

            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sms.Send">Send()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sms_call_send_finish() to get the result of the operation.
             *
             * See mm_gdbus_sms_call_send_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_send(cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sms.Send">Send()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sms_call_send_finish() to get the result of the operation.
             *
             * See mm_gdbus_sms_call_send_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_send(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sms.Send">Send()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sms_call_send_finish() to get the result of the operation.
             *
             * See mm_gdbus_sms_call_send_sync() for the synchronous, blocking version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_send(
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_sms_call_send().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_sms_call_send().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_send_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sms.Send">Send()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_sms_call_send() for the asynchronous version of this method.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_send_sync(cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sms.Store">Store()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sms_call_store_finish() to get the result of the operation.
             *
             * See mm_gdbus_sms_call_store_sync() for the synchronous, blocking version of this method.
             * @param arg_storage Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             */
            call_store(arg_storage: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sms.Store">Store()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sms_call_store_finish() to get the result of the operation.
             *
             * See mm_gdbus_sms_call_store_sync() for the synchronous, blocking version of this method.
             * @param arg_storage Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_store(
                arg_storage: number,
                cancellable: Gio.Cancellable | null,
                callback: Gio.AsyncReadyCallback<this> | null,
            ): void;
            /**
             * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sms.Store">Store()</link> D-Bus method on `proxy`.
             * When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
             * You can then call mm_gdbus_sms_call_store_finish() to get the result of the operation.
             *
             * See mm_gdbus_sms_call_store_sync() for the synchronous, blocking version of this method.
             * @param arg_storage Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
             */
            call_store(
                arg_storage: number,
                cancellable?: Gio.Cancellable | null,
                callback?: Gio.AsyncReadyCallback<this> | null,
            ): Promise<boolean> | void;
            /**
             * Finishes an operation started with mm_gdbus_sms_call_store().
             * @param res The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_gdbus_sms_call_store().
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_store_finish(res: Gio.AsyncResult): boolean;
            /**
             * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sms.Store">Store()</link> D-Bus method on `proxy`. The calling thread is blocked until a reply is received.
             *
             * See mm_gdbus_sms_call_store() for the asynchronous version of this method.
             * @param arg_storage Argument to pass with the method invocation.
             * @param cancellable A #GCancellable or %NULL.
             * @returns %TRUE if the call succeeded, %FALSE if @error is set.
             */
            call_store_sync(arg_storage: number, cancellable?: Gio.Cancellable | null): boolean;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sms.Send">Send()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_send(invocation: Gio.DBusMethodInvocation): void;
            /**
             * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-ModemManager1-Sms.Store">Store()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
             *
             * This method will free `invocation,` you cannot use it afterwards.
             * @param invocation A #GDBusMethodInvocation.
             */
            complete_store(invocation: Gio.DBusMethodInvocation): void;

            // Virtual methods

            vfunc_handle_send(invocation: Gio.DBusMethodInvocation): boolean;
            vfunc_handle_store(invocation: Gio.DBusMethodInvocation, arg_storage: number): boolean;
        }

        export const GdbusSms: GdbusSmsNamespace & {
            new (): GdbusSms; // This allows `obj instanceof GdbusSms`
        };

        /**
         * Name of the imported GIR library
         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
         */
        const __name__: string;
        /**
         * Version of the imported GIR library
         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
         */
        const __version__: string;
    }

    export default ModemManager;
}

declare module 'gi://ModemManager' {
    import ModemManager10 from 'gi://ModemManager?version=1.0';
    export default ModemManager10;
}
// END