Basic Connect

## Basic Connect Basic Connect |

## Synopsis

                        MbimPinDesc;
    void                mbim_pin_desc_free                  (MbimPinDesc *var);

                        MbimProvider;
    void                mbim_provider_free                  (MbimProvider *var);
    void                mbim_provider_array_free            (MbimProvider **array);

                        MbimProvisionedContextElement;
    void                mbim_provisioned_context_element_array_free
                                                            (MbimProvisionedContextElement **array);

                        MbimIPv4Element;
    void                mbim_ipv4_element_array_free        (MbimIPv4Element **array);

                        MbimIPv6Element;
    void                mbim_ipv6_element_array_free        (MbimIPv6Element **array);

                        MbimDeviceServiceElement;
    void                mbim_device_service_element_array_free
                                                            (MbimDeviceServiceElement **array);

                        MbimEventEntry;
    void                mbim_event_entry_array_free         (MbimEventEntry **array);

                        MbimPacketFilter;
    void                mbim_packet_filter_array_free       (MbimPacketFilter **array);

    MbimMessage *       mbim_message_device_caps_query_new  (GError **error);
    gboolean            mbim_message_device_caps_response_parse
                                                            (const MbimMessage *message,
                                                             MbimDeviceType *device_type,
                                                             MbimCellularClass *cellular_class,
                                                             MbimVoiceClass *voice_class,
                                                             MbimSimClass *sim_class,
                                                             MbimDataClass *data_class,
                                                             MbimSmsCaps *sms_caps,
                                                             MbimCtrlCaps *control_caps,
                                                             guint32 *max_sessions,
                                                             gchar **custom_data_class,
                                                             gchar **device_id,
                                                             gchar **firmware_info,
                                                             gchar **hardware_info,
                                                             GError **error);

    MbimMessage *       mbim_message_subscriber_ready_status_query_new
                                                            (GError **error);
    gboolean            mbim_message_subscriber_ready_status_response_parse
                                                            (const MbimMessage *message,
                                                             MbimSubscriberReadyState *ready_state,
                                                             gchar **subscriber_id,
                                                             gchar **sim_icc_id,
                                                             MbimReadyInfoFlag *ready_info,
                                                             guint32 *telephone_numbers_count,
                                                             gchar ***telephone_numbers,
                                                             GError **error);

    MbimMessage *       mbim_message_radio_state_query_new  (GError **error);
    MbimMessage *       mbim_message_radio_state_set_new    (MbimRadioSwitchState radio_state,
                                                             GError **error);
    gboolean            mbim_message_radio_state_response_parse
                                                            (const MbimMessage *message,
                                                             MbimRadioSwitchState *hw_radio_state,
                                                             MbimRadioSwitchState *sw_radio_state,
                                                             GError **error);
    gboolean            mbim_message_radio_state_notification_parse
                                                            (const MbimMessage *message,
                                                             MbimRadioSwitchState *hw_radio_state,
                                                             MbimRadioSwitchState *sw_radio_state,
                                                             GError **error);

    MbimMessage *       mbim_message_pin_query_new          (GError **error);
    MbimMessage *       mbim_message_pin_set_new            (MbimPinType pin_type,
                                                             MbimPinOperation pin_operation,
                                                             const gchar *pin,
                                                             const gchar *new_pin,
                                                             GError **error);
    gboolean            mbim_message_pin_response_parse     (const MbimMessage *message,
                                                             MbimPinType *pin_type,
                                                             MbimPinState *pin_state,
                                                             guint32 *remaining_attempts,
                                                             GError **error);

    MbimMessage *       mbim_message_pin_list_query_new     (GError **error);
    gboolean            mbim_message_pin_list_response_parse
                                                            (const MbimMessage *message,
                                                             MbimPinDesc **pin_desc_pin1,
                                                             MbimPinDesc **pin_desc_pin2,
                                                             MbimPinDesc **pin_desc_device_sim_pin,
                                                             MbimPinDesc **pin_desc_device_first_sim_pin,
                                                             MbimPinDesc **pin_desc_network_pin,
                                                             MbimPinDesc **pin_desc_network_subset_pin,
                                                             MbimPinDesc **pin_desc_service_provider_pin,
                                                             MbimPinDesc **pin_desc_corporate_pin,
                                                             MbimPinDesc **pin_desc_subsidy_lock,
                                                             MbimPinDesc **pin_desc_custom,
                                                             GError **error);

    MbimMessage *       mbim_message_home_provider_query_new
                                                            (GError **error);
    MbimMessage *       mbim_message_home_provider_set_new  (const MbimProvider *provider,
                                                             GError **error);
    gboolean            mbim_message_home_provider_response_parse
                                                            (const MbimMessage *message,
                                                             MbimProvider **provider,
                                                             GError **error);

    MbimMessage *       mbim_message_preferred_providers_query_new
                                                            (GError **error);
    MbimMessage *       mbim_message_preferred_providers_set_new
                                                            (guint32 providers_count,
                                                             const MbimProvider *const *providers,
                                                             GError **error);
    gboolean            mbim_message_preferred_providers_response_parse
                                                            (const MbimMessage *message,
                                                             guint32 *providers_count,
                                                             MbimProvider ***providers,
                                                             GError **error);

    MbimMessage *       mbim_message_visible_providers_query_new
                                                            (MbimVisibleProvidersAction action,
                                                             GError **error);
    gboolean            mbim_message_visible_providers_response_parse
                                                            (const MbimMessage *message,
                                                             guint32 *providers_count,
                                                             MbimProvider ***providers,
                                                             GError **error);

    MbimMessage *       mbim_message_register_state_query_new
                                                            (GError **error);
    MbimMessage *       mbim_message_register_state_set_new (const gchar *provider_id,
                                                             MbimRegisterAction register_action,
                                                             MbimDataClass data_class,
                                                             GError **error);
    gboolean            mbim_message_register_state_response_parse
                                                            (const MbimMessage *message,
                                                             MbimNwError *nw_error,
                                                             MbimRegisterState *register_state,
                                                             MbimRegisterMode *register_mode,
                                                             MbimDataClass *available_data_classes,
                                                             MbimCellularClass *current_cellular_class,
                                                             gchar **provider_id,
                                                             gchar **provider_name,
                                                             gchar **roaming_text,
                                                             MbimRegistrationFlag *registration_flag,
                                                             GError **error);
    gboolean            mbim_message_register_state_notification_parse
                                                            (const MbimMessage *message,
                                                             MbimNwError *nw_error,
                                                             MbimRegisterState *register_state,
                                                             MbimRegisterMode *register_mode,
                                                             MbimDataClass *available_data_classes,
                                                             MbimCellularClass *current_cellular_class,
                                                             gchar **provider_id,
                                                             gchar **provider_name,
                                                             gchar **roaming_text,
                                                             MbimRegistrationFlag *registration_flag,
                                                             GError **error);

    MbimMessage *       mbim_message_signal_state_query_new (GError **error);
    MbimMessage *       mbim_message_signal_state_set_new   (guint32 signal_strength_interval,
                                                             guint32 rssi_threshold,
                                                             guint32 error_rate_threshold,
                                                             GError **error);
    gboolean            mbim_message_signal_state_response_parse
                                                            (const MbimMessage *message,
                                                             guint32 *rssi,
                                                             guint32 *error_rate,
                                                             guint32 *signal_strength_interval,
                                                             guint32 *rssi_threshold,
                                                             guint32 *error_rate_threshold,
                                                             GError **error);
    gboolean            mbim_message_signal_state_notification_parse
                                                            (const MbimMessage *message,
                                                             guint32 *rssi,
                                                             guint32 *error_rate,
                                                             guint32 *signal_strength_interval,
                                                             guint32 *rssi_threshold,
                                                             guint32 *error_rate_threshold,
                                                             GError **error);

    MbimMessage *       mbim_message_packet_service_query_new
                                                            (GError **error);
    MbimMessage *       mbim_message_packet_service_set_new (MbimPacketServiceAction packet_service_action,
                                                             GError **error);
    gboolean            mbim_message_packet_service_response_parse
                                                            (const MbimMessage *message,
                                                             guint32 *nw_error,
                                                             MbimPacketServiceState *packet_service_state,
                                                             MbimDataClass *highest_available_data_class,
                                                             guint64 *uplink_speed,
                                                             guint64 *downlink_speed,
                                                             GError **error);
    gboolean            mbim_message_packet_service_notification_parse
                                                            (const MbimMessage *message,
                                                             guint32 *nw_error,
                                                             MbimPacketServiceState *packet_service_state,
                                                             MbimDataClass *highest_available_data_class,
                                                             guint64 *uplink_speed,
                                                             guint64 *downlink_speed,
                                                             GError **error);

    MbimMessage *       mbim_message_connect_query_new      (guint32 session_id,
                                                             MbimActivationState activation_state,
                                                             MbimVoiceCallState voice_call_state,
                                                             MbimContextIpType ip_type,
                                                             const MbimUuid *context_type,
                                                             guint32 nw_error,
                                                             GError **error);
    MbimMessage *       mbim_message_connect_set_new        (guint32 session_id,
                                                             MbimActivationCommand activation_command,
                                                             const gchar *access_string,
                                                             const gchar *user_name,
                                                             const gchar *password,
                                                             MbimCompression compression,
                                                             MbimAuthProtocol auth_protocol,
                                                             MbimContextIpType ip_type,
                                                             const MbimUuid *context_type,
                                                             GError **error);
    gboolean            mbim_message_connect_response_parse (const MbimMessage *message,
                                                             guint32 *session_id,
                                                             MbimActivationState *activation_state,
                                                             MbimVoiceCallState *voice_call_state,
                                                             MbimContextIpType *ip_type,
                                                             const MbimUuid **context_type,
                                                             guint32 *nw_error,
                                                             GError **error);
    gboolean            mbim_message_connect_notification_parse
                                                            (const MbimMessage *message,
                                                             guint32 *session_id,
                                                             MbimActivationState *activation_state,
                                                             MbimVoiceCallState *voice_call_state,
                                                             MbimContextIpType *ip_type,
                                                             const MbimUuid **context_type,
                                                             guint32 *nw_error,
                                                             GError **error);

    MbimMessage *       mbim_message_provisioned_contexts_query_new
                                                            (GError **error);
    MbimMessage *       mbim_message_provisioned_contexts_set_new
                                                            (guint32 context_id,
                                                             const MbimUuid *context_type,
                                                             const gchar *access_string,
                                                             const gchar *user_name,
                                                             const gchar *password,
                                                             MbimCompression compression,
                                                             MbimAuthProtocol auth_protocol,
                                                             const gchar *provider_id,
                                                             GError **error);
    gboolean            mbim_message_provisioned_contexts_response_parse
                                                            (const MbimMessage *message,
                                                             guint32 *provisioned_contexts_count,
                                                             MbimProvisionedContextElement ***provisioned_contexts,
                                                             GError **error);
    gboolean            mbim_message_provisioned_contexts_notification_parse
                                                            (const MbimMessage *message,
                                                             guint32 *provisioned_contexts_count,
                                                             MbimProvisionedContextElement ***provisioned_contexts,
                                                             GError **error);

    MbimMessage *       mbim_message_service_activation_set_new
                                                            (const guint32 buffer_size,
                                                             const guint8 *buffer,
                                                             GError **error);
    gboolean            mbim_message_service_activation_response_parse
                                                            (const MbimMessage *message,
                                                             MbimNwError *nw_error,
                                                             guint32 *buffer_size,
                                                             const guint8 **buffer,
                                                             GError **error);

    MbimMessage *       mbim_message_ip_configuration_query_new
                                                            (guint32 session_id,
                                                             MbimIPConfigurationAvailableFlag ipv4_configuration_available,
                                                             MbimIPConfigurationAvailableFlag ipv6_configuration_available,
                                                             guint32 ipv4_address_count,
                                                             const MbimIPv4Element *const *ipv4_address,
                                                             guint32 ipv6_address_count,
                                                             const MbimIPv6Element *const *ipv6_address,
                                                             const MbimIPv4 *ipv4_gateway,
                                                             const MbimIPv6 *ipv6_gateway,
                                                             guint32 ipv4_dns_server_count,
                                                             const MbimIPv4 *ipv4_dns_server,
                                                             guint32 ipv6_dns_server_count,
                                                             const MbimIPv6 *ipv6_dns_server,
                                                             guint32 ipv4_mtu,
                                                             guint32 ipv6_mtu,
                                                             GError **error);
    gboolean            mbim_message_ip_configuration_response_parse
                                                            (const MbimMessage *message,
                                                             guint32 *session_id,
                                                             MbimIPConfigurationAvailableFlag *ipv4_configuration_available,
                                                             MbimIPConfigurationAvailableFlag *ipv6_configuration_available,
                                                             guint32 *ipv4_address_count,
                                                             MbimIPv4Element ***ipv4_address,
                                                             guint32 *ipv6_address_count,
                                                             MbimIPv6Element ***ipv6_address,
                                                             const MbimIPv4 **ipv4_gateway,
                                                             const MbimIPv6 **ipv6_gateway,
                                                             guint32 *ipv4_dns_server_count,
                                                             MbimIPv4 **ipv4_dns_server,
                                                             guint32 *ipv6_dns_server_count,
                                                             MbimIPv6 **ipv6_dns_server,
                                                             guint32 *ipv4_mtu,
                                                             guint32 *ipv6_mtu,
                                                             GError **error);
    gboolean            mbim_message_ip_configuration_notification_parse
                                                            (const MbimMessage *message,
                                                             guint32 *session_id,
                                                             MbimIPConfigurationAvailableFlag *ipv4_configuration_available,
                                                             MbimIPConfigurationAvailableFlag *ipv6_configuration_available,
                                                             guint32 *ipv4_address_count,
                                                             MbimIPv4Element ***ipv4_address,
                                                             guint32 *ipv6_address_count,
                                                             MbimIPv6Element ***ipv6_address,
                                                             const MbimIPv4 **ipv4_gateway,
                                                             const MbimIPv6 **ipv6_gateway,
                                                             guint32 *ipv4_dns_server_count,
                                                             MbimIPv4 **ipv4_dns_server,
                                                             guint32 *ipv6_dns_server_count,
                                                             MbimIPv6 **ipv6_dns_server,
                                                             guint32 *ipv4_mtu,
                                                             guint32 *ipv6_mtu,
                                                             GError **error);

    MbimMessage *       mbim_message_device_services_query_new
                                                            (GError **error);
    gboolean            mbim_message_device_services_response_parse
                                                            (const MbimMessage *message,
                                                             guint32 *device_services_count,
                                                             guint32 *max_dss_sessions,
                                                             MbimDeviceServiceElement ***device_services,
                                                             GError **error);

    MbimMessage *       mbim_message_device_service_subscriber_list_set_new
                                                            (guint32 events_count,
                                                             const MbimEventEntry *const *events,
                                                             GError **error);
    gboolean            mbim_message_device_service_subscriber_list_response_parse
                                                            (const MbimMessage *message,
                                                             guint32 *events_count,
                                                             MbimEventEntry ***events,
                                                             GError **error);

    MbimMessage *       mbim_message_packet_statistics_query_new
                                                            (GError **error);
    gboolean            mbim_message_packet_statistics_response_parse
                                                            (const MbimMessage *message,
                                                             guint32 *in_discards,
                                                             guint32 *in_errors,
                                                             guint64 *in_octets,
                                                             guint64 *in_packets,
                                                             guint64 *out_octets,
                                                             guint64 *out_packets,
                                                             guint32 *out_errors,
                                                             guint32 *out_discards,
                                                             GError **error);

    MbimMessage *       mbim_message_network_idle_hint_query_new
                                                            (GError **error);
    MbimMessage *       mbim_message_network_idle_hint_set_new
                                                            (MbimNetworkIdleHintState state,
                                                             GError **error);
    gboolean            mbim_message_network_idle_hint_response_parse
                                                            (const MbimMessage *message,
                                                             MbimNetworkIdleHintState *state,
                                                             GError **error);

    MbimMessage *       mbim_message_emergency_mode_query_new
                                                            (GError **error);
    MbimMessage *       mbim_message_emergency_mode_set_new (MbimEmergencyModeState state,
                                                             GError **error);
    gboolean            mbim_message_emergency_mode_response_parse
                                                            (const MbimMessage *message,
                                                             MbimEmergencyModeState *state,
                                                             GError **error);

    MbimMessage *       mbim_message_ip_packet_filters_query_new
                                                            (guint32 session_id,
                                                             guint32 packet_filters_count,
                                                             const MbimPacketFilter *const *packet_filters,
                                                             GError **error);
    MbimMessage *       mbim_message_ip_packet_filters_set_new
                                                            (guint32 session_id,
                                                             guint32 packet_filters_count,
                                                             const MbimPacketFilter *const *packet_filters,
                                                             GError **error);
    gboolean            mbim_message_ip_packet_filters_response_parse
                                                            (const MbimMessage *message,
                                                             guint32 *session_id,
                                                             guint32 *packet_filters_count,
                                                             MbimPacketFilter ***packet_filters,
                                                             GError **error);

    MbimMessage *       mbim_message_multicarrier_providers_query_new
                                                            (GError **error);
    MbimMessage *       mbim_message_multicarrier_providers_set_new
                                                            (guint32 providers_count,
                                                             const MbimProvider *const *providers,
                                                             GError **error);
    gboolean            mbim_message_multicarrier_providers_response_parse
                                                            (const MbimMessage *message,
                                                             guint32 *providers_count,
                                                             MbimProvider ***providers,
                                                             GError **error);

## Description

## Details

### MbimPinDesc

    typedef struct {
        guint32 pin_mode;
        guint32 pin_format;
        guint32 pin_length_min;
        guint32 pin_length_max;
    } MbimPinDesc;

guint32 `pin_mode`; | a guint32.
guint32 `pin_format`; | a guint32.
guint32 `pin_length_min`; | a guint32.
guint32 `pin_length_max`; | a guint32.

### mbim_pin_desc_free ()

    void                mbim_pin_desc_free                  (MbimPinDesc *var);

Frees the memory allocated for the MbimPinDesc.

`var` : | a MbimPinDesc.

### MbimProvider

    typedef struct {
        gchar *provider_id;
        guint32 provider_state;
        gchar *provider_name;
        guint32 cellular_class;
        guint32 rssi;
        guint32 error_rate;
    } MbimProvider;

gchar *`provider_id`; | a string.
guint32 `provider_state`; | a guint32.
gchar *`provider_name`; | a string.
guint32 `cellular_class`; | a guint32.
guint32 `rssi`; | a guint32.
guint32 `error_rate`; | a guint32.

### mbim_provider_free ()

    void                mbim_provider_free                  (MbimProvider *var);

Frees the memory allocated for the MbimProvider.

`var` : | a MbimProvider.

### mbim_provider_array_free ()

    void                mbim_provider_array_free            (MbimProvider **array);

Frees the memory allocated for the array of MbimProviders.

`array` : | a NULL terminated array of MbimProvider structs.

### MbimProvisionedContextElement

    typedef struct {
        guint32 context_id;
        MbimUuid context_type;
        gchar *access_string;
        gchar *user_name;
        gchar *password;
        guint32 compression;
        guint32 auth_protocol;
    } MbimProvisionedContextElement;

guint32 `context_id`; | a guint32.
MbimUuid `context_type`; | a MbimUuid.
gchar *`access_string`; | a string.
gchar *`user_name`; | a string.
gchar *`password`; | a string.
guint32 `compression`; | a guint32.
guint32 `auth_protocol`; | a guint32.

### mbim_provisioned_context_element_array_free ()

    void                mbim_provisioned_context_element_array_free
                                                            (MbimProvisionedContextElement **array);

Frees the memory allocated for the array of MbimProvisionedContextElements.

`array` : | a NULL terminated array of MbimProvisionedContextElement structs.

### MbimIPv4Element

    typedef struct {
        guint32 on_link_prefix_length;
        MbimIPv4 ipv4_address;
    } MbimIPv4Element;

guint32 `on_link_prefix_length`; | a guint32.
MbimIPv4 `ipv4_address`; | a MbimIPv4.

### mbim_ipv4_element_array_free ()

    void                mbim_ipv4_element_array_free        (MbimIPv4Element **array);

Frees the memory allocated for the array of MbimIPv4Elements.

`array` : | a NULL terminated array of MbimIPv4Element structs.

### MbimIPv6Element

    typedef struct {
        guint32 on_link_prefix_length;
        MbimIPv6 ipv6_address;
    } MbimIPv6Element;

guint32 `on_link_prefix_length`; | a guint32.
MbimIPv6 `ipv6_address`; | a MbimIPv6

### mbim_ipv6_element_array_free ()

    void                mbim_ipv6_element_array_free        (MbimIPv6Element **array);

Frees the memory allocated for the array of MbimIPv6Elements.

`array` : | a NULL terminated array of MbimIPv6Element structs.

### MbimDeviceServiceElement

    typedef struct {
        MbimUuid device_service_id;
        guint32 dss_payload;
        guint32 max_dss_instances;
        guint32 cids_count;
        guint32 *cids;
    } MbimDeviceServiceElement;

MbimUuid `device_service_id`; | a MbimUuid.
guint32 `dss_payload`; | a guint32.
guint32 `max_dss_instances`; | a guint32.
guint32 `cids_count`; | a guint32.
guint32 *`cids`; | an array of guint32 values.

### mbim_device_service_element_array_free ()

    void                mbim_device_service_element_array_free
                                                            (MbimDeviceServiceElement **array);

Frees the memory allocated for the array of MbimDeviceServiceElements.

`array` : | a NULL terminated array of MbimDeviceServiceElement structs.

### MbimEventEntry

    typedef struct {
        MbimUuid device_service_id;
        guint32 cids_count;
        guint32 *cids;
    } MbimEventEntry;

MbimUuid `device_service_id`; | a MbimUuid.
guint32 `cids_count`; | a guint32.
guint32 *`cids`; | an array of guint32 values.

### mbim_event_entry_array_free ()

    void                mbim_event_entry_array_free         (MbimEventEntry **array);

Frees the memory allocated for the array of MbimEventEntrys.

`array` : | a NULL terminated array of MbimEventEntry structs.

### MbimPacketFilter

    typedef struct {
        guint32 filter_size;
        guint8 *packet_filter;
        guint8 *packet_mask;
    } MbimPacketFilter;

guint32 `filter_size`; | a guint32.
guint8 *`packet_filter`; | an array of guint8 values.
guint8 *`packet_mask`; | an array of guint8 values.

### mbim_packet_filter_array_free ()

    void                mbim_packet_filter_array_free       (MbimPacketFilter **array);

Frees the memory allocated for the array of MbimPacketFilters.

`array` : | a NULL terminated array of MbimPacketFilter structs.

### mbim_message_device_caps_query_new ()

    MbimMessage *       mbim_message_device_caps_query_new  (GError **error);

Create a new request for the 'Device Caps' query command in the 'Basic Connect' service.

`error` : | return location for error or `NULL`.
Returns : | a newly allocated MbimMessage, which should be freed with `mbim_message_unref()`.

### mbim_message_device_caps_response_parse ()

    gboolean            mbim_message_device_caps_response_parse
                                                            (const MbimMessage *message,
                                                             MbimDeviceType *device_type,
                                                             MbimCellularClass *cellular_class,
                                                             MbimVoiceClass *voice_class,
                                                             MbimSimClass *sim_class,
                                                             MbimDataClass *data_class,
                                                             MbimSmsCaps *sms_caps,
                                                             MbimCtrlCaps *control_caps,
                                                             guint32 *max_sessions,
                                                             gchar **custom_data_class,
                                                             gchar **device_id,
                                                             gchar **firmware_info,
                                                             gchar **hardware_info,
                                                             GError **error);

Create a new request for the 'HardwareInfo' response command in the 'Basic Connect' service.

`message` : | the MbimMessage.
`device_type` : | return location for a MbimDeviceType, or `NULL` if the 'DeviceType' field is not needed.
`cellular_class` : | return location for a MbimCellularClass, or `NULL` if the 'CellularClass' field is not needed.
`voice_class` : | return location for a MbimVoiceClass, or `NULL` if the 'VoiceClass' field is not needed.
`sim_class` : | return location for a MbimSimClass, or `NULL` if the 'SimClass' field is not needed.
`data_class` : | return location for a MbimDataClass, or `NULL` if the 'DataClass' field is not needed.
`sms_caps` : | return location for a MbimSmsCaps, or `NULL` if the 'SmsCaps' field is not needed.
`control_caps` : | return location for a MbimCtrlCaps, or `NULL` if the 'ControlCaps' field is not needed.
`max_sessions` : | return location for a guint32, or `NULL` if the 'MaxSessions' field is not needed.
`custom_data_class` : | return location for a newly allocated string, or `NULL` if the 'CustomDataClass' field is not needed. Free the returned value with `g_free()`.
`device_id` : | return location for a newly allocated string, or `NULL` if the 'DeviceId' field is not needed. Free the returned value with `g_free()`.
`firmware_info` : | return location for a newly allocated string, or `NULL` if the 'FirmwareInfo' field is not needed. Free the returned value with `g_free()`.
`hardware_info` : | return location for a newly allocated string, or `NULL` if the 'HardwareInfo' field is not needed. Free the returned value with `g_free()`.
`error` : | return location for error or `NULL`.
Returns : | `TRUE` if the message was correctly parsed, `FALSE` if `error` is set.

### mbim_message_subscriber_ready_status_query_new ()

    MbimMessage *       mbim_message_subscriber_ready_status_query_new
                                                            (GError **error);

Create a new request for the 'Subscriber Ready Status' query command in the 'Basic Connect' service.

`error` : | return location for error or `NULL`.
Returns : | a newly allocated MbimMessage, which should be freed with `mbim_message_unref()`.

### mbim_message_subscriber_ready_status_response_parse ()

    gboolean            mbim_message_subscriber_ready_status_response_parse
                                                            (const MbimMessage *message,
                                                             MbimSubscriberReadyState *ready_state,
                                                             gchar **subscriber_id,
                                                             gchar **sim_icc_id,
                                                             MbimReadyInfoFlag *ready_info,
                                                             guint32 *telephone_numbers_count,
                                                             gchar ***telephone_numbers,
                                                             GError **error);

Create a new request for the 'TelephoneNumbers' response command in the 'Basic Connect' service.

`message` : | the MbimMessage.
`ready_state` : | return location for a MbimSubscriberReadyState, or `NULL` if the 'ReadyState' field is not needed.
`subscriber_id` : | return location for a newly allocated string, or `NULL` if the 'SubscriberID' field is not needed. Free the returned value with `g_free()`.
`sim_icc_id` : | return location for a newly allocated string, or `NULL` if the 'SimIccId' field is not needed. Free the returned value with `g_free()`.
`ready_info` : | return location for a MbimReadyInfoFlag, or `NULL` if the 'ReadyInfo' field is not needed.
`telephone_numbers_count` : | return location for a guint32, or `NULL` if the 'TelephoneNumbersCount' field is not needed.
`telephone_numbers` : | return location for a newly allocated array of strings, or `NULL` if the 'TelephoneNumbers' field is not needed. Free the returned value with `g_strfreev()`.
`error` : | return location for error or `NULL`.
Returns : | `TRUE` if the message was correctly parsed, `FALSE` if `error` is set.

### mbim_message_radio_state_query_new ()

    MbimMessage *       mbim_message_radio_state_query_new  (GError **error);

Create a new request for the 'Radio State' query command in the 'Basic Connect' service.

`error` : | return location for error or `NULL`.
Returns : | a newly allocated MbimMessage, which should be freed with `mbim_message_unref()`.

### mbim_message_radio_state_set_new ()

    MbimMessage *       mbim_message_radio_state_set_new    (MbimRadioSwitchState radio_state,
                                                             GError **error);

Create a new request for the 'Radio State' set command in the 'Basic Connect' service.

`radio_state` : | the 'RadioState' field, given as a MbimRadioSwitchState.
`error` : | return location for error or `NULL`.
Returns : | a newly allocated MbimMessage, which should be freed with `mbim_message_unref()`.

### mbim_message_radio_state_response_parse ()

    gboolean            mbim_message_radio_state_response_parse
                                                            (const MbimMessage *message,
                                                             MbimRadioSwitchState *hw_radio_state,
                                                             MbimRadioSwitchState *sw_radio_state,
                                                             GError **error);

Create a new request for the 'SwRadioState' response command in the 'Basic Connect' service.

`message` : | the MbimMessage.
`hw_radio_state` : | return location for a MbimRadioSwitchState, or `NULL` if the 'HwRadioState' field is not needed.
`sw_radio_state` : | return location for a MbimRadioSwitchState, or `NULL` if the 'SwRadioState' field is not needed.
`error` : | return location for error or `NULL`.
Returns : | `TRUE` if the message was correctly parsed, `FALSE` if `error` is set.

### mbim_message_radio_state_notification_parse ()

    gboolean            mbim_message_radio_state_notification_parse
                                                            (const MbimMessage *message,
                                                             MbimRadioSwitchState *hw_radio_state,
                                                             MbimRadioSwitchState *sw_radio_state,
                                                             GError **error);

Create a new request for the 'SwRadioState' notification command in the 'Basic Connect' service.

`message` : | the MbimMessage.
`hw_radio_state` : | return location for a MbimRadioSwitchState, or `NULL` if the 'HwRadioState' field is not needed.
`sw_radio_state` : | return location for a MbimRadioSwitchState, or `NULL` if the 'SwRadioState' field is not needed.
`error` : | return location for error or `NULL`.
Returns : | `TRUE` if the message was correctly parsed, `FALSE` if `error` is set.

### mbim_message_pin_query_new ()

    MbimMessage *       mbim_message_pin_query_new          (GError **error);

Create a new request for the 'Pin' query command in the 'Basic Connect' service.

`error` : | return location for error or `NULL`.
Returns : | a newly allocated MbimMessage, which should be freed with `mbim_message_unref()`.

### mbim_message_pin_set_new ()

    MbimMessage *       mbim_message_pin_set_new            (MbimPinType pin_type,
                                                             MbimPinOperation pin_operation,
                                                             const gchar *pin,
                                                             const gchar *new_pin,
                                                             GError **error);

Create a new request for the 'Pin' set command in the 'Basic Connect' service.

`pin_type` : | the 'PinType' field, given as a MbimPinType.
`pin_operation` : | the 'PinOperation' field, given as a MbimPinOperation.
`pin` : | the 'Pin' field, given as a string.
`new_pin` : | the 'NewPin' field, given as a string.
`error` : | return location for error or `NULL`.
Returns : | a newly allocated MbimMessage, which should be freed with `mbim_message_unref()`.

### mbim_message_pin_response_parse ()

    gboolean            mbim_message_pin_response_parse     (const MbimMessage *message,
                                                             MbimPinType *pin_type,
                                                             MbimPinState *pin_state,
                                                             guint32 *remaining_attempts,
                                                             GError **error);

Create a new request for the 'RemainingAttempts' response command in the 'Basic Connect' service.

`message` : | the MbimMessage.
`pin_type` : | return location for a MbimPinType, or `NULL` if the 'PinType' field is not needed.
`pin_state` : | return location for a MbimPinState, or `NULL` if the 'PinState' field is not needed.
`remaining_attempts` : | return location for a guint32, or `NULL` if the 'RemainingAttempts' field is not needed.
`error` : | return location for error or `NULL`.
Returns : | `TRUE` if the message was correctly parsed, `FALSE` if `error` is set.

### mbim_message_pin_list_query_new ()

    MbimMessage *       mbim_message_pin_list_query_new     (GError **error);

Create a new request for the 'Pin List' query command in the 'Basic Connect' service.

`error` : | return location for error or `NULL`.
Returns : | a newly allocated MbimMessage, which should be freed with `mbim_message_unref()`.

### mbim_message_pin_list_response_parse ()

    gboolean            mbim_message_pin_list_response_parse
                                                            (const MbimMessage *message,
                                                             MbimPinDesc **pin_desc_pin1,
                                                             MbimPinDesc **pin_desc_pin2,
                                                             MbimPinDesc **pin_desc_device_sim_pin,
                                                             MbimPinDesc **pin_desc_device_first_sim_pin,
                                                             MbimPinDesc **pin_desc_network_pin,
                                                             MbimPinDesc **pin_desc_network_subset_pin,
                                                             MbimPinDesc **pin_desc_service_provider_pin,
                                                             MbimPinDesc **pin_desc_corporate_pin,
                                                             MbimPinDesc **pin_desc_subsidy_lock,
                                                             MbimPinDesc **pin_desc_custom,
                                                             GError **error);

Create a new request for the 'PinDescCustom' response command in the 'Basic Connect' service.

`message` : | the MbimMessage.
`pin_desc_pin1` : | return location for a newly allocated MbimPinDesc, or `NULL` if the 'PinDescPin1' field is not needed. Free the returned value with `mbim_pin_desc_free()`.
`pin_desc_pin2` : | return location for a newly allocated MbimPinDesc, or `NULL` if the 'PinDescPin2' field is not needed. Free the returned value with `mbim_pin_desc_free()`.
`pin_desc_device_sim_pin` : | return location for a newly allocated MbimPinDesc, or `NULL` if the 'PinDescDeviceSimPin' field is not needed. Free the returned value with `mbim_pin_desc_free()`.
`pin_desc_device_first_sim_pin` : | return location for a newly allocated MbimPinDesc, or `NULL` if the 'PinDescDeviceFirstSimPin' field is not needed. Free the returned value with `mbim_pin_desc_free()`.
`pin_desc_network_pin` : | return location for a newly allocated MbimPinDesc, or `NULL` if the 'PinDescNetworkPin' field is not needed. Free the returned value with `mbim_pin_desc_free()`.
`pin_desc_network_subset_pin` : | return location for a newly allocated MbimPinDesc, or `NULL` if the 'PinDescNetworkSubsetPin' field is not needed. Free the returned value with `mbim_pin_desc_free()`.
`pin_desc_service_provider_pin` : | return location for a newly allocated MbimPinDesc, or `NULL` if the 'PinDescServiceProviderPin' field is not needed. Free the returned value with `mbim_pin_desc_free()`.
`pin_desc_corporate_pin` : | return location for a newly allocated MbimPinDesc, or `NULL` if the 'PinDescCorporatePin' field is not needed. Free the returned value with `mbim_pin_desc_free()`.
`pin_desc_subsidy_lock` : | return location for a newly allocated MbimPinDesc, or `NULL` if the 'PinDescSubsidyLock' field is not needed. Free the returned value with `mbim_pin_desc_free()`.
`pin_desc_custom` : | return location for a newly allocated MbimPinDesc, or `NULL` if the 'PinDescCustom' field is not needed. Free the returned value with `mbim_pin_desc_free()`.
`error` : | return location for error or `NULL`.
Returns : | `TRUE` if the message was correctly parsed, `FALSE` if `error` is set.

### mbim_message_home_provider_query_new ()

    MbimMessage *       mbim_message_home_provider_query_new
                                                            (GError **error);

Create a new request for the 'Home Provider' query command in the 'Basic Connect' service.

`error` : | return location for error or `NULL`.
Returns : | a newly allocated MbimMessage, which should be freed with `mbim_message_unref()`.

### mbim_message_home_provider_set_new ()

    MbimMessage *       mbim_message_home_provider_set_new  (const MbimProvider *provider,
                                                             GError **error);

Create a new request for the 'Home Provider' set command in the 'Basic Connect' service.

`provider` : | the 'Provider' field, given as a MbimProvider.
`error` : | return location for error or `NULL`.
Returns : | a newly allocated MbimMessage, which should be freed with `mbim_message_unref()`.

### mbim_message_home_provider_response_parse ()

    gboolean            mbim_message_home_provider_response_parse
                                                            (const MbimMessage *message,
                                                             MbimProvider **provider,
                                                             GError **error);

Create a new request for the 'Provider' response command in the 'Basic Connect' service.

`message` : | the MbimMessage.
`provider` : | return location for a newly allocated MbimProvider, or `NULL` if the 'Provider' field is not needed. Free the returned value with `mbim_provider_free()`.
`error` : | return location for error or `NULL`.
Returns : | `TRUE` if the message was correctly parsed, `FALSE` if `error` is set.

### mbim_message_preferred_providers_query_new ()

    MbimMessage *       mbim_message_preferred_providers_query_new
                                                            (GError **error);

Create a new request for the 'Preferred Providers' query command in the 'Basic Connect' service.

`error` : | return location for error or `NULL`.
Returns : | a newly allocated MbimMessage, which should be freed with `mbim_message_unref()`.

### mbim_message_preferred_providers_set_new ()

    MbimMessage *       mbim_message_preferred_providers_set_new
                                                            (guint32 providers_count,
                                                             const MbimProvider *const *providers,
                                                             GError **error);

Create a new request for the 'Preferred Providers' set command in the 'Basic Connect' service.

`providers_count` : | the 'ProvidersCount' field, given as a guint32.
`providers` : | the 'Providers' field, given as an array of MbimProviders.
`error` : | return location for error or `NULL`.
Returns : | a newly allocated MbimMessage, which should be freed with `mbim_message_unref()`.

### mbim_message_preferred_providers_response_parse ()

    gboolean            mbim_message_preferred_providers_response_parse
                                                            (const MbimMessage *message,
                                                             guint32 *providers_count,
                                                             MbimProvider ***providers,
                                                             GError **error);

Create a new request for the 'Providers' response command in the 'Basic Connect' service.

`message` : | the MbimMessage.
`providers_count` : | return location for a guint32, or `NULL` if the 'ProvidersCount' field is not needed.
`providers` : | return location for a newly allocated array of MbimProviders, or `NULL` if the 'Providers' field is not needed. Free the returned value with `mbim_provider_array_free()`.
`error` : | return location for error or `NULL`.
Returns : | `TRUE` if the message was correctly parsed, `FALSE` if `error` is set.

### mbim_message_visible_providers_query_new ()

    MbimMessage *       mbim_message_visible_providers_query_new
                                                            (MbimVisibleProvidersAction action,
                                                             GError **error);

Create a new request for the 'Visible Providers' query command in the 'Basic Connect' service.

`action` : | the 'Action' field, given as a MbimVisibleProvidersAction.
`error` : | return location for error or `NULL`.
Returns : | a newly allocated MbimMessage, which should be freed with `mbim_message_unref()`.

### mbim_message_visible_providers_response_parse ()

    gboolean            mbim_message_visible_providers_response_parse
                                                            (const MbimMessage *message,
                                                             guint32 *providers_count,
                                                             MbimProvider ***providers,
                                                             GError **error);

Create a new request for the 'Providers' response command in the 'Basic Connect' service.

`message` : | the MbimMessage.
`providers_count` : | return location for a guint32, or `NULL` if the 'ProvidersCount' field is not needed.
`providers` : | return location for a newly allocated array of MbimProviders, or `NULL` if the 'Providers' field is not needed. Free the returned value with `mbim_provider_array_free()`.
`error` : | return location for error or `NULL`.
Returns : | `TRUE` if the message was correctly parsed, `FALSE` if `error` is set.

### mbim_message_register_state_query_new ()

    MbimMessage *       mbim_message_register_state_query_new
                                                            (GError **error);

Create a new request for the 'Register State' query command in the 'Basic Connect' service.

`error` : | return location for error or `NULL`.
Returns : | a newly allocated MbimMessage, which should be freed with `mbim_message_unref()`.

### mbim_message_register_state_set_new ()

    MbimMessage *       mbim_message_register_state_set_new (const gchar *provider_id,
                                                             MbimRegisterAction register_action,
                                                             MbimDataClass data_class,
                                                             GError **error);

Create a new request for the 'Register State' set command in the 'Basic Connect' service.

`provider_id` : | the 'ProviderId' field, given as a string.
`register_action` : | the 'RegisterAction' field, given as a MbimRegisterAction.
`data_class` : | the 'DataClass' field, given as a MbimDataClass.
`error` : | return location for error or `NULL`.
Returns : | a newly allocated MbimMessage, which should be freed with `mbim_message_unref()`.

### mbim_message_register_state_response_parse ()

    gboolean            mbim_message_register_state_response_parse
                                                            (const MbimMessage *message,
                                                             MbimNwError *nw_error,
                                                             MbimRegisterState *register_state,
                                                             MbimRegisterMode *register_mode,
                                                             MbimDataClass *available_data_classes,
                                                             MbimCellularClass *current_cellular_class,
                                                             gchar **provider_id,
                                                             gchar **provider_name,
                                                             gchar **roaming_text,
                                                             MbimRegistrationFlag *registration_flag,
                                                             GError **error);

Create a new request for the 'RegistrationFlag' response command in the 'Basic Connect' service.

`message` : | the MbimMessage.
`nw_error` : | return location for a MbimNwError, or `NULL` if the 'NwError' field is not needed.
`register_state` : | return location for a MbimRegisterState, or `NULL` if the 'RegisterState' field is not needed.
`register_mode` : | return location for a MbimRegisterMode, or `NULL` if the 'RegisterMode' field is not needed.
`available_data_classes` : | return location for a MbimDataClass, or `NULL` if the 'AvailableDataClasses' field is not needed.
`current_cellular_class` : | return location for a MbimCellularClass, or `NULL` if the 'CurrentCellularClass' field is not needed.
`provider_id` : | return location for a newly allocated string, or `NULL` if the 'ProviderId' field is not needed. Free the returned value with `g_free()`.
`provider_name` : | return location for a newly allocated string, or `NULL` if the 'ProviderName' field is not needed. Free the returned value with `g_free()`.
`roaming_text` : | return location for a newly allocated string, or `NULL` if the 'RoamingText' field is not needed. Free the returned value with `g_free()`.
`registration_flag` : | return location for a MbimRegistrationFlag, or `NULL` if the 'RegistrationFlag' field is not needed.
`error` : | return location for error or `NULL`.
Returns : | `TRUE` if the message was correctly parsed, `FALSE` if `error` is set.

### mbim_message_register_state_notification_parse ()

    gboolean            mbim_message_register_state_notification_parse
                                                            (const MbimMessage *message,
                                                             MbimNwError *nw_error,
                                                             MbimRegisterState *register_state,
                                                             MbimRegisterMode *register_mode,
                                                             MbimDataClass *available_data_classes,
                                                             MbimCellularClass *current_cellular_class,
                                                             gchar **provider_id,
                                                             gchar **provider_name,
                                                             gchar **roaming_text,
                                                             MbimRegistrationFlag *registration_flag,
                                                             GError **error);

Create a new request for the 'RegistrationFlag' notification command in the 'Basic Connect' service.

`message` : | the MbimMessage.
`nw_error` : | return location for a MbimNwError, or `NULL` if the 'NwError' field is not needed.
`register_state` : | return location for a MbimRegisterState, or `NULL` if the 'RegisterState' field is not needed.
`register_mode` : | return location for a MbimRegisterMode, or `NULL` if the 'RegisterMode' field is not needed.
`available_data_classes` : | return location for a MbimDataClass, or `NULL` if the 'AvailableDataClasses' field is not needed.
`current_cellular_class` : | return location for a MbimCellularClass, or `NULL` if the 'CurrentCellularClass' field is not needed.
`provider_id` : | return location for a newly allocated string, or `NULL` if the 'ProviderId' field is not needed. Free the returned value with `g_free()`.
`provider_name` : | return location for a newly allocated string, or `NULL` if the 'ProviderName' field is not needed. Free the returned value with `g_free()`.
`roaming_text` : | return location for a newly allocated string, or `NULL` if the 'RoamingText' field is not needed. Free the returned value with `g_free()`.
`registration_flag` : | return location for a MbimRegistrationFlag, or `NULL` if the 'RegistrationFlag' field is not needed.
`error` : | return location for error or `NULL`.
Returns : | `TRUE` if the message was correctly parsed, `FALSE` if `error` is set.

### mbim_message_signal_state_query_new ()

    MbimMessage *       mbim_message_signal_state_query_new (GError **error);

Create a new request for the 'Signal State' query command in the 'Basic Connect' service.

`error` : | return location for error or `NULL`.
Returns : | a newly allocated MbimMessage, which should be freed with `mbim_message_unref()`.

### mbim_message_signal_state_set_new ()

    MbimMessage *       mbim_message_signal_state_set_new   (guint32 signal_strength_interval,
                                                             guint32 rssi_threshold,
                                                             guint32 error_rate_threshold,
                                                             GError **error);

Create a new request for the 'Signal State' set command in the 'Basic Connect' service.

`signal_strength_interval` : | the 'SignalStrengthInterval' field, given as a guint32.
`rssi_threshold` : | the 'RssiThreshold' field, given as a guint32.
`error_rate_threshold` : | the 'ErrorRateThreshold' field, given as a guint32.
`error` : | return location for error or `NULL`.
Returns : | a newly allocated MbimMessage, which should be freed with `mbim_message_unref()`.

### mbim_message_signal_state_response_parse ()

    gboolean            mbim_message_signal_state_response_parse
                                                            (const MbimMessage *message,
                                                             guint32 *rssi,
                                                             guint32 *error_rate,
                                                             guint32 *signal_strength_interval,
                                                             guint32 *rssi_threshold,
                                                             guint32 *error_rate_threshold,
                                                             GError **error);

Create a new request for the 'ErrorRateThreshold' response command in the 'Basic Connect' service.

`message` : | the MbimMessage.
`rssi` : | return location for a guint32, or `NULL` if the 'Rssi' field is not needed.
`error_rate` : | return location for a guint32, or `NULL` if the 'ErrorRate' field is not needed.
`signal_strength_interval` : | return location for a guint32, or `NULL` if the 'SignalStrengthInterval' field is not needed.
`rssi_threshold` : | return location for a guint32, or `NULL` if the 'RssiThreshold' field is not needed.
`error_rate_threshold` : | return location for a guint32, or `NULL` if the 'ErrorRateThreshold' field is not needed.
`error` : | return location for error or `NULL`.
Returns : | `TRUE` if the message was correctly parsed, `FALSE` if `error` is set.

### mbim_message_signal_state_notification_parse ()

    gboolean            mbim_message_signal_state_notification_parse
                                                            (const MbimMessage *message,
                                                             guint32 *rssi,
                                                             guint32 *error_rate,
                                                             guint32 *signal_strength_interval,
                                                             guint32 *rssi_threshold,
                                                             guint32 *error_rate_threshold,
                                                             GError **error);

Create a new request for the 'ErrorRateThreshold' notification command in the 'Basic Connect' service.

`message` : | the MbimMessage.
`rssi` : | return location for a guint32, or `NULL` if the 'Rssi' field is not needed.
`error_rate` : | return location for a guint32, or `NULL` if the 'ErrorRate' field is not needed.
`signal_strength_interval` : | return location for a guint32, or `NULL` if the 'SignalStrengthInterval' field is not needed.
`rssi_threshold` : | return location for a guint32, or `NULL` if the 'RssiThreshold' field is not needed.
`error_rate_threshold` : | return location for a guint32, or `NULL` if the 'ErrorRateThreshold' field is not needed.
`error` : | return location for error or `NULL`.
Returns : | `TRUE` if the message was correctly parsed, `FALSE` if `error` is set.

### mbim_message_packet_service_query_new ()

    MbimMessage *       mbim_message_packet_service_query_new
                                                            (GError **error);

Create a new request for the 'Packet Service' query command in the 'Basic Connect' service.

`error` : | return location for error or `NULL`.
Returns : | a newly allocated MbimMessage, which should be freed with `mbim_message_unref()`.

### mbim_message_packet_service_set_new ()

    MbimMessage *       mbim_message_packet_service_set_new (MbimPacketServiceAction packet_service_action,
                                                             GError **error);

Create a new request for the 'Packet Service' set command in the 'Basic Connect' service.

`packet_service_action` : | the 'PacketServiceAction' field, given as a MbimPacketServiceAction.
`error` : | return location for error or `NULL`.
Returns : | a newly allocated MbimMessage, which should be freed with `mbim_message_unref()`.

### mbim_message_packet_service_response_parse ()

    gboolean            mbim_message_packet_service_response_parse
                                                            (const MbimMessage *message,
                                                             guint32 *nw_error,
                                                             MbimPacketServiceState *packet_service_state,
                                                             MbimDataClass *highest_available_data_class,
                                                             guint64 *uplink_speed,
                                                             guint64 *downlink_speed,
                                                             GError **error);

Create a new request for the 'DownlinkSpeed' response command in the 'Basic Connect' service.

`message` : | the MbimMessage.
`nw_error` : | return location for a guint32, or `NULL` if the 'NwError' field is not needed.
`packet_service_state` : | return location for a MbimPacketServiceState, or `NULL` if the 'PacketServiceState' field is not needed.
`highest_available_data_class` : | return location for a MbimDataClass, or `NULL` if the 'HighestAvailableDataClass' field is not needed.
`uplink_speed` : | return location for a guint64, or `NULL` if the 'UplinkSpeed' field is not needed.
`downlink_speed` : | return location for a guint64, or `NULL` if the 'DownlinkSpeed' field is not needed.
`error` : | return location for error or `NULL`.
Returns : | `TRUE` if the message was correctly parsed, `FALSE` if `error` is set.

### mbim_message_packet_service_notification_parse ()

    gboolean            mbim_message_packet_service_notification_parse
                                                            (const MbimMessage *message,
                                                             guint32 *nw_error,
                                                             MbimPacketServiceState *packet_service_state,
                                                             MbimDataClass *highest_available_data_class,
                                                             guint64 *uplink_speed,
                                                             guint64 *downlink_speed,
                                                             GError **error);

Create a new request for the 'DownlinkSpeed' notification command in the 'Basic Connect' service.

`message` : | the MbimMessage.
`nw_error` : | return location for a guint32, or `NULL` if the 'NwError' field is not needed.
`packet_service_state` : | return location for a MbimPacketServiceState, or `NULL` if the 'PacketServiceState' field is not needed.
`highest_available_data_class` : | return location for a MbimDataClass, or `NULL` if the 'HighestAvailableDataClass' field is not needed.
`uplink_speed` : | return location for a guint64, or `NULL` if the 'UplinkSpeed' field is not needed.
`downlink_speed` : | return location for a guint64, or `NULL` if the 'DownlinkSpeed' field is not needed.
`error` : | return location for error or `NULL`.
Returns : | `TRUE` if the message was correctly parsed, `FALSE` if `error` is set.

### mbim_message_connect_query_new ()

    MbimMessage *       mbim_message_connect_query_new      (guint32 session_id,
                                                             MbimActivationState activation_state,
                                                             MbimVoiceCallState voice_call_state,
                                                             MbimContextIpType ip_type,
                                                             const MbimUuid *context_type,
                                                             guint32 nw_error,
                                                             GError **error);

Create a new request for the 'Connect' query command in the 'Basic Connect' service.

`session_id` : | the 'SessionId' field, given as a guint32.
`activation_state` : | the 'ActivationState' field, given as a MbimActivationState.
`voice_call_state` : | the 'VoiceCallState' field, given as a MbimVoiceCallState.
`ip_type` : | the 'IpType' field, given as a MbimContextIpType.
`context_type` : | the 'ContextType' field, given as a MbimUuid.
`nw_error` : | the 'NwError' field, given as a guint32.
`error` : | return location for error or `NULL`.
Returns : | a newly allocated MbimMessage, which should be freed with `mbim_message_unref()`.

### mbim_message_connect_set_new ()

    MbimMessage *       mbim_message_connect_set_new        (guint32 session_id,
                                                             MbimActivationCommand activation_command,
                                                             const gchar *access_string,
                                                             const gchar *user_name,
                                                             const gchar *password,
                                                             MbimCompression compression,
                                                             MbimAuthProtocol auth_protocol,
                                                             MbimContextIpType ip_type,
                                                             const MbimUuid *context_type,
                                                             GError **error);

Create a new request for the 'Connect' set command in the 'Basic Connect' service.

`session_id` : | the 'SessionId' field, given as a guint32.
`activation_command` : | the 'ActivationCommand' field, given as a MbimActivationCommand.
`access_string` : | the 'AccessString' field, given as a string.
`user_name` : | the 'UserName' field, given as a string.
`password` : | the 'Password' field, given as a string.
`compression` : | the 'Compression' field, given as a MbimCompression.
`auth_protocol` : | the 'AuthProtocol' field, given as a MbimAuthProtocol.
`ip_type` : | the 'IpType' field, given as a MbimContextIpType.
`context_type` : | the 'ContextType' field, given as a MbimUuid.
`error` : | return location for error or `NULL`.
Returns : | a newly allocated MbimMessage, which should be freed with `mbim_message_unref()`.

### mbim_message_connect_response_parse ()

    gboolean            mbim_message_connect_response_parse (const MbimMessage *message,
                                                             guint32 *session_id,
                                                             MbimActivationState *activation_state,
                                                             MbimVoiceCallState *voice_call_state,
                                                             MbimContextIpType *ip_type,
                                                             const MbimUuid **context_type,
                                                             guint32 *nw_error,
                                                             GError **error);

Create a new request for the 'NwError' response command in the 'Basic Connect' service.

`message` : | the MbimMessage.
`session_id` : | return location for a guint32, or `NULL` if the 'SessionId' field is not needed.
`activation_state` : | return location for a MbimActivationState, or `NULL` if the 'ActivationState' field is not needed.
`voice_call_state` : | return location for a MbimVoiceCallState, or `NULL` if the 'VoiceCallState' field is not needed.
`ip_type` : | return location for a MbimContextIpType, or `NULL` if the 'IpType' field is not needed.
`context_type` : | return location for a MbimUuid, or `NULL` if the 'ContextType' field is not needed. Do not free the returned value, it is owned by `message`.
`nw_error` : | return location for a guint32, or `NULL` if the 'NwError' field is not needed.
`error` : | return location for error or `NULL`.
Returns : | `TRUE` if the message was correctly parsed, `FALSE` if `error` is set.

### mbim_message_connect_notification_parse ()

    gboolean            mbim_message_connect_notification_parse
                                                            (const MbimMessage *message,
                                                             guint32 *session_id,
                                                             MbimActivationState *activation_state,
                                                             MbimVoiceCallState *voice_call_state,
                                                             MbimContextIpType *ip_type,
                                                             const MbimUuid **context_type,
                                                             guint32 *nw_error,
                                                             GError **error);

Create a new request for the 'NwError' notification command in the 'Basic Connect' service.

`message` : | the MbimMessage.
`session_id` : | return location for a guint32, or `NULL` if the 'SessionId' field is not needed.
`activation_state` : | return location for a MbimActivationState, or `NULL` if the 'ActivationState' field is not needed.
`voice_call_state` : | return location for a MbimVoiceCallState, or `NULL` if the 'VoiceCallState' field is not needed.
`ip_type` : | return location for a MbimContextIpType, or `NULL` if the 'IpType' field is not needed.
`context_type` : | return location for a MbimUuid, or `NULL` if the 'ContextType' field is not needed. Do not free the returned value, it is owned by `message`.
`nw_error` : | return location for a guint32, or `NULL` if the 'NwError' field is not needed.
`error` : | return location for error or `NULL`.
Returns : | `TRUE` if the message was correctly parsed, `FALSE` if `error` is set.

### mbim_message_provisioned_contexts_query_new ()

    MbimMessage *       mbim_message_provisioned_contexts_query_new
                                                            (GError **error);

Create a new request for the 'Provisioned Contexts' query command in the 'Basic Connect' service.

`error` : | return location for error or `NULL`.
Returns : | a newly allocated MbimMessage, which should be freed with `mbim_message_unref()`.

### mbim_message_provisioned_contexts_set_new ()

    MbimMessage *       mbim_message_provisioned_contexts_set_new
                                                            (guint32 context_id,
                                                             const MbimUuid *context_type,
                                                             const gchar *access_string,
                                                             const gchar *user_name,
                                                             const gchar *password,
                                                             MbimCompression compression,
                                                             MbimAuthProtocol auth_protocol,
                                                             const gchar *provider_id,
                                                             GError **error);

Create a new request for the 'Provisioned Contexts' set command in the 'Basic Connect' service.

`context_id` : | the 'ContextId' field, given as a guint32.
`context_type` : | the 'ContextType' field, given as a MbimUuid.
`access_string` : | the 'AccessString' field, given as a string.
`user_name` : | the 'UserName' field, given as a string.
`password` : | the 'Password' field, given as a string.
`compression` : | the 'Compression' field, given as a MbimCompression.
`auth_protocol` : | the 'AuthProtocol' field, given as a MbimAuthProtocol.
`provider_id` : | the 'ProviderId' field, given as a string.
`error` : | return location for error or `NULL`.
Returns : | a newly allocated MbimMessage, which should be freed with `mbim_message_unref()`.

### mbim_message_provisioned_contexts_response_parse ()

    gboolean            mbim_message_provisioned_contexts_response_parse
                                                            (const MbimMessage *message,
                                                             guint32 *provisioned_contexts_count,
                                                             MbimProvisionedContextElement ***provisioned_contexts,
                                                             GError **error);

Create a new request for the 'ProvisionedContexts' response command in the 'Basic Connect' service.

`message` : | the MbimMessage.
`provisioned_contexts_count` : | return location for a guint32, or `NULL` if the 'ProvisionedContextsCount' field is not needed.
`provisioned_contexts` : | return location for a newly allocated array of MbimProvisionedContextElements, or `NULL` if the 'ProvisionedContexts' field is not needed. Free the returned value with `mbim_provisioned_context_element_array_free()`.
`error` : | return location for error or `NULL`.
Returns : | `TRUE` if the message was correctly parsed, `FALSE` if `error` is set.

### mbim_message_provisioned_contexts_notification_parse ()

    gboolean            mbim_message_provisioned_contexts_notification_parse
                                                            (const MbimMessage *message,
                                                             guint32 *provisioned_contexts_count,
                                                             MbimProvisionedContextElement ***provisioned_contexts,
                                                             GError **error);

Create a new request for the 'ProvisionedContexts' notification command in the 'Basic Connect' service.

`message` : | the MbimMessage.
`provisioned_contexts_count` : | return location for a guint32, or `NULL` if the 'ProvisionedContextsCount' field is not needed.
`provisioned_contexts` : | return location for a newly allocated array of MbimProvisionedContextElements, or `NULL` if the 'ProvisionedContexts' field is not needed. Free the returned value with `mbim_provisioned_context_element_array_free()`.
`error` : | return location for error or `NULL`.
Returns : | `TRUE` if the message was correctly parsed, `FALSE` if `error` is set.

### mbim_message_service_activation_set_new ()

    MbimMessage *       mbim_message_service_activation_set_new
                                                            (const guint32 buffer_size,
                                                             const guint8 *buffer,
                                                             GError **error);

Create a new request for the 'Service Activation' set command in the 'Basic Connect' service.

`buffer_size` : | size of the buffer array.
`buffer` : | the 'Buffer' field, given as an array of guint8 values.
`error` : | return location for error or `NULL`.
Returns : | a newly allocated MbimMessage, which should be freed with `mbim_message_unref()`.

### mbim_message_service_activation_response_parse ()

    gboolean            mbim_message_service_activation_response_parse
                                                            (const MbimMessage *message,
                                                             MbimNwError *nw_error,
                                                             guint32 *buffer_size,
                                                             const guint8 **buffer,
                                                             GError **error);

Create a new request for the 'Buffer' response command in the 'Basic Connect' service.

`message` : | the MbimMessage.
`nw_error` : | return location for a MbimNwError, or `NULL` if the 'NwError' field is not needed.
`buffer_size` : | return location for the size of the buffer array.
`buffer` : | return location for an array of guint8 values. Do not free the returned value, it is owned by `message`.
`error` : | return location for error or `NULL`.
Returns : | `TRUE` if the message was correctly parsed, `FALSE` if `error` is set.

### mbim_message_ip_configuration_query_new ()

    MbimMessage *       mbim_message_ip_configuration_query_new
                                                            (guint32 session_id,
                                                             MbimIPConfigurationAvailableFlag ipv4_configuration_available,
                                                             MbimIPConfigurationAvailableFlag ipv6_configuration_available,
                                                             guint32 ipv4_address_count,
                                                             const MbimIPv4Element *const *ipv4_address,
                                                             guint32 ipv6_address_count,
                                                             const MbimIPv6Element *const *ipv6_address,
                                                             const MbimIPv4 *ipv4_gateway,
                                                             const MbimIPv6 *ipv6_gateway,
                                                             guint32 ipv4_dns_server_count,
                                                             const MbimIPv4 *ipv4_dns_server,
                                                             guint32 ipv6_dns_server_count,
                                                             const MbimIPv6 *ipv6_dns_server,
                                                             guint32 ipv4_mtu,
                                                             guint32 ipv6_mtu,
                                                             GError **error);

Create a new request for the 'IP Configuration' query command in the 'Basic Connect' service.

`session_id` : | the 'SessionId' field, given as a guint32.
`ipv4_configuration_available` : | the 'IPv4ConfigurationAvailable' field, given as a MbimIPConfigurationAvailableFlag.
`ipv6_configuration_available` : | the 'IPv6ConfigurationAvailable' field, given as a MbimIPConfigurationAvailableFlag.
`ipv4_address_count` : | the 'IPv4AddressCount' field, given as a guint32.
`ipv4_address` : | the 'IPv4Address' field, given as an array of MbimIPv4Elements.
`ipv6_address_count` : | the 'IPv6AddressCount' field, given as a guint32.
`ipv6_address` : | the 'IPv6Address' field, given as an array of MbimIPv6Elements.
`ipv4_gateway` : | the 'IPv4Gateway' field, given as a MbimIPv4.
`ipv6_gateway` : | the 'IPv6Gateway' field, given as a MbimIPv6.
`ipv4_dns_server_count` : | the 'IPv4DnsServerCount' field, given as a guint32.
`ipv4_dns_server` : | the 'IPv4DnsServer' field, given as an array of MbimIPv4.
`ipv6_dns_server_count` : | the 'IPv6DnsServerCount' field, given as a guint32.
`ipv6_dns_server` : | the 'IPv6DnsServer' field, given as an array of MbimIPv6.
`ipv4_mtu` : | the 'IPv4Mtu' field, given as a guint32.
`ipv6_mtu` : | the 'IPv6Mtu' field, given as a guint32.
`error` : | return location for error or `NULL`.
Returns : | a newly allocated MbimMessage, which should be freed with `mbim_message_unref()`.

### mbim_message_ip_configuration_response_parse ()

    gboolean            mbim_message_ip_configuration_response_parse
                                                            (const MbimMessage *message,
                                                             guint32 *session_id,
                                                             MbimIPConfigurationAvailableFlag *ipv4_configuration_available,
                                                             MbimIPConfigurationAvailableFlag *ipv6_configuration_available,
                                                             guint32 *ipv4_address_count,
                                                             MbimIPv4Element ***ipv4_address,
                                                             guint32 *ipv6_address_count,
                                                             MbimIPv6Element ***ipv6_address,
                                                             const MbimIPv4 **ipv4_gateway,
                                                             const MbimIPv6 **ipv6_gateway,
                                                             guint32 *ipv4_dns_server_count,
                                                             MbimIPv4 **ipv4_dns_server,
                                                             guint32 *ipv6_dns_server_count,
                                                             MbimIPv6 **ipv6_dns_server,
                                                             guint32 *ipv4_mtu,
                                                             guint32 *ipv6_mtu,
                                                             GError **error);

Create a new request for the 'IPv6Mtu' response command in the 'Basic Connect' service.

`message` : | the MbimMessage.
`session_id` : | return location for a guint32, or `NULL` if the 'SessionId' field is not needed.
`ipv4_configuration_available` : | return location for a MbimIPConfigurationAvailableFlag, or `NULL` if the 'IPv4ConfigurationAvailable' field is not needed.
`ipv6_configuration_available` : | return location for a MbimIPConfigurationAvailableFlag, or `NULL` if the 'IPv6ConfigurationAvailable' field is not needed.
`ipv4_address_count` : | return location for a guint32, or `NULL` if the 'IPv4AddressCount' field is not needed.
`ipv4_address` : | return location for a newly allocated array of MbimIPv4Elements, or `NULL` if the 'IPv4Address' field is not needed. Free the returned value with `mbim_ipv4_element_array_free()`.
`ipv6_address_count` : | return location for a guint32, or `NULL` if the 'IPv6AddressCount' field is not needed.
`ipv6_address` : | return location for a newly allocated array of MbimIPv6Elements, or `NULL` if the 'IPv6Address' field is not needed. Free the returned value with `mbim_ipv6_element_array_free()`.
`ipv4_gateway` : | return location for a MbimIPv4, or `NULL` if the 'IPv4Gateway' field is not needed. Do not free the returned value, it is owned by `message`.
`ipv6_gateway` : | return location for a MbimIPv6, or `NULL` if the 'IPv6Gateway' field is not needed. Do not free the returned value, it is owned by `message`.
`ipv4_dns_server_count` : | return location for a guint32, or `NULL` if the 'IPv4DnsServerCount' field is not needed.
`ipv4_dns_server` : | return location for a newly allocated array of MbimIPv4s, or `NULL` if the 'IPv4DnsServer' field is not needed. Free the returned value with `g_free()`.
`ipv6_dns_server_count` : | return location for a guint32, or `NULL` if the 'IPv6DnsServerCount' field is not needed.
`ipv6_dns_server` : | return location for a newly allocated array of MbimIPv6s, or `NULL` if the 'IPv6DnsServer' field is not needed. Free the returned value with `g_free()`.
`ipv4_mtu` : | return location for a guint32, or `NULL` if the 'IPv4Mtu' field is not needed.
`ipv6_mtu` : | return location for a guint32, or `NULL` if the 'IPv6Mtu' field is not needed.
`error` : | return location for error or `NULL`.
Returns : | `TRUE` if the message was correctly parsed, `FALSE` if `error` is set.

### mbim_message_ip_configuration_notification_parse ()

    gboolean            mbim_message_ip_configuration_notification_parse
                                                            (const MbimMessage *message,
                                                             guint32 *session_id,
                                                             MbimIPConfigurationAvailableFlag *ipv4_configuration_available,
                                                             MbimIPConfigurationAvailableFlag *ipv6_configuration_available,
                                                             guint32 *ipv4_address_count,
                                                             MbimIPv4Element ***ipv4_address,
                                                             guint32 *ipv6_address_count,
                                                             MbimIPv6Element ***ipv6_address,
                                                             const MbimIPv4 **ipv4_gateway,
                                                             const MbimIPv6 **ipv6_gateway,
                                                             guint32 *ipv4_dns_server_count,
                                                             MbimIPv4 **ipv4_dns_server,
                                                             guint32 *ipv6_dns_server_count,
                                                             MbimIPv6 **ipv6_dns_server,
                                                             guint32 *ipv4_mtu,
                                                             guint32 *ipv6_mtu,
                                                             GError **error);

Create a new request for the 'IPv6Mtu' notification command in the 'Basic Connect' service.

`message` : | the MbimMessage.
`session_id` : | return location for a guint32, or `NULL` if the 'SessionId' field is not needed.
`ipv4_configuration_available` : | return location for a MbimIPConfigurationAvailableFlag, or `NULL` if the 'IPv4ConfigurationAvailable' field is not needed.
`ipv6_configuration_available` : | return location for a MbimIPConfigurationAvailableFlag, or `NULL` if the 'IPv6ConfigurationAvailable' field is not needed.
`ipv4_address_count` : | return location for a guint32, or `NULL` if the 'IPv4AddressCount' field is not needed.
`ipv4_address` : | return location for a newly allocated array of MbimIPv4Elements, or `NULL` if the 'IPv4Address' field is not needed. Free the returned value with `mbim_ipv4_element_array_free()`.
`ipv6_address_count` : | return location for a guint32, or `NULL` if the 'IPv6AddressCount' field is not needed.
`ipv6_address` : | return location for a newly allocated array of MbimIPv6Elements, or `NULL` if the 'IPv6Address' field is not needed. Free the returned value with `mbim_ipv6_element_array_free()`.
`ipv4_gateway` : | return location for a MbimIPv4, or `NULL` if the 'IPv4Gateway' field is not needed. Do not free the returned value, it is owned by `message`.
`ipv6_gateway` : | return location for a MbimIPv6, or `NULL` if the 'IPv6Gateway' field is not needed. Do not free the returned value, it is owned by `message`.
`ipv4_dns_server_count` : | return location for a guint32, or `NULL` if the 'IPv4DnsServerCount' field is not needed.
`ipv4_dns_server` : | return location for a newly allocated array of MbimIPv4s, or `NULL` if the 'IPv4DnsServer' field is not needed. Free the returned value with `g_free()`.
`ipv6_dns_server_count` : | return location for a guint32, or `NULL` if the 'IPv6DnsServerCount' field is not needed.
`ipv6_dns_server` : | return location for a newly allocated array of MbimIPv6s, or `NULL` if the 'IPv6DnsServer' field is not needed. Free the returned value with `g_free()`.
`ipv4_mtu` : | return location for a guint32, or `NULL` if the 'IPv4Mtu' field is not needed.
`ipv6_mtu` : | return location for a guint32, or `NULL` if the 'IPv6Mtu' field is not needed.
`error` : | return location for error or `NULL`.
Returns : | `TRUE` if the message was correctly parsed, `FALSE` if `error` is set.

### mbim_message_device_services_query_new ()

    MbimMessage *       mbim_message_device_services_query_new
                                                            (GError **error);

Create a new request for the 'Device Services' query command in the 'Basic Connect' service.

`error` : | return location for error or `NULL`.
Returns : | a newly allocated MbimMessage, which should be freed with `mbim_message_unref()`.

### mbim_message_device_services_response_parse ()

    gboolean            mbim_message_device_services_response_parse
                                                            (const MbimMessage *message,
                                                             guint32 *device_services_count,
                                                             guint32 *max_dss_sessions,
                                                             MbimDeviceServiceElement ***device_services,
                                                             GError **error);

Create a new request for the 'DeviceServices' response command in the 'Basic Connect' service.

`message` : | the MbimMessage.
`device_services_count` : | return location for a guint32, or `NULL` if the 'DeviceServicesCount' field is not needed.
`max_dss_sessions` : | return location for a guint32, or `NULL` if the 'MaxDssSessions' field is not needed.
`device_services` : | return location for a newly allocated array of MbimDeviceServiceElements, or `NULL` if the 'DeviceServices' field is not needed. Free the returned value with `mbim_device_service_element_array_free()`.
`error` : | return location for error or `NULL`.
Returns : | `TRUE` if the message was correctly parsed, `FALSE` if `error` is set.

### mbim_message_device_service_subscriber_list_set_new ()

    MbimMessage *       mbim_message_device_service_subscriber_list_set_new
                                                            (guint32 events_count,
                                                             const MbimEventEntry *const *events,
                                                             GError **error);

Create a new request for the 'Device Service Subscriber List' set command in the 'Basic Connect' service.

`events_count` : | the 'EventsCount' field, given as a guint32.
`events` : | the 'Events' field, given as an array of MbimEventEntrys.
`error` : | return location for error or `NULL`.
Returns : | a newly allocated MbimMessage, which should be freed with `mbim_message_unref()`.

### mbim_message_device_service_subscriber_list_response_parse ()

    gboolean            mbim_message_device_service_subscriber_list_response_parse
                                                            (const MbimMessage *message,
                                                             guint32 *events_count,
                                                             MbimEventEntry ***events,
                                                             GError **error);

Create a new request for the 'Events' response command in the 'Basic Connect' service.

`message` : | the MbimMessage.
`events_count` : | return location for a guint32, or `NULL` if the 'EventsCount' field is not needed.
`events` : | return location for a newly allocated array of MbimEventEntrys, or `NULL` if the 'Events' field is not needed. Free the returned value with `mbim_event_entry_array_free()`.
`error` : | return location for error or `NULL`.
Returns : | `TRUE` if the message was correctly parsed, `FALSE` if `error` is set.

### mbim_message_packet_statistics_query_new ()

    MbimMessage *       mbim_message_packet_statistics_query_new
                                                            (GError **error);

Create a new request for the 'Packet Statistics' query command in the 'Basic Connect' service.

`error` : | return location for error or `NULL`.
Returns : | a newly allocated MbimMessage, which should be freed with `mbim_message_unref()`.

### mbim_message_packet_statistics_response_parse ()

    gboolean            mbim_message_packet_statistics_response_parse
                                                            (const MbimMessage *message,
                                                             guint32 *in_discards,
                                                             guint32 *in_errors,
                                                             guint64 *in_octets,
                                                             guint64 *in_packets,
                                                             guint64 *out_octets,
                                                             guint64 *out_packets,
                                                             guint32 *out_errors,
                                                             guint32 *out_discards,
                                                             GError **error);

Create a new request for the 'OutDiscards' response command in the 'Basic Connect' service.

`message` : | the MbimMessage.
`in_discards` : | return location for a guint32, or `NULL` if the 'InDiscards' field is not needed.
`in_errors` : | return location for a guint32, or `NULL` if the 'InErrors' field is not needed.
`in_octets` : | return location for a guint64, or `NULL` if the 'InOctets' field is not needed.
`in_packets` : | return location for a guint64, or `NULL` if the 'InPackets' field is not needed.
`out_octets` : | return location for a guint64, or `NULL` if the 'OutOctets' field is not needed.
`out_packets` : | return location for a guint64, or `NULL` if the 'OutPackets' field is not needed.
`out_errors` : | return location for a guint32, or `NULL` if the 'OutErrors' field is not needed.
`out_discards` : | return location for a guint32, or `NULL` if the 'OutDiscards' field is not needed.
`error` : | return location for error or `NULL`.
Returns : | `TRUE` if the message was correctly parsed, `FALSE` if `error` is set.

### mbim_message_network_idle_hint_query_new ()

    MbimMessage *       mbim_message_network_idle_hint_query_new
                                                            (GError **error);

Create a new request for the 'Network Idle Hint' query command in the 'Basic Connect' service.

`error` : | return location for error or `NULL`.
Returns : | a newly allocated MbimMessage, which should be freed with `mbim_message_unref()`.

### mbim_message_network_idle_hint_set_new ()

    MbimMessage *       mbim_message_network_idle_hint_set_new
                                                            (MbimNetworkIdleHintState state,
                                                             GError **error);

Create a new request for the 'Network Idle Hint' set command in the 'Basic Connect' service.

`state` : | the 'State' field, given as a MbimNetworkIdleHintState.
`error` : | return location for error or `NULL`.
Returns : | a newly allocated MbimMessage, which should be freed with `mbim_message_unref()`.

### mbim_message_network_idle_hint_response_parse ()

    gboolean            mbim_message_network_idle_hint_response_parse
                                                            (const MbimMessage *message,
                                                             MbimNetworkIdleHintState *state,
                                                             GError **error);

Create a new request for the 'State' response command in the 'Basic Connect' service.

`message` : | the MbimMessage.
`state` : | return location for a MbimNetworkIdleHintState, or `NULL` if the 'State' field is not needed.
`error` : | return location for error or `NULL`.
Returns : | `TRUE` if the message was correctly parsed, `FALSE` if `error` is set.

### mbim_message_emergency_mode_query_new ()

    MbimMessage *       mbim_message_emergency_mode_query_new
                                                            (GError **error);

Create a new request for the 'Emergency Mode' query command in the 'Basic Connect' service.

`error` : | return location for error or `NULL`.
Returns : | a newly allocated MbimMessage, which should be freed with `mbim_message_unref()`.

### mbim_message_emergency_mode_set_new ()

    MbimMessage *       mbim_message_emergency_mode_set_new (MbimEmergencyModeState state,
                                                             GError **error);

Create a new request for the 'Emergency Mode' set command in the 'Basic Connect' service.

`state` : | the 'State' field, given as a MbimEmergencyModeState.
`error` : | return location for error or `NULL`.
Returns : | a newly allocated MbimMessage, which should be freed with `mbim_message_unref()`.

### mbim_message_emergency_mode_response_parse ()

    gboolean            mbim_message_emergency_mode_response_parse
                                                            (const MbimMessage *message,
                                                             MbimEmergencyModeState *state,
                                                             GError **error);

Create a new request for the 'State' response command in the 'Basic Connect' service.

`message` : | the MbimMessage.
`state` : | return location for a MbimEmergencyModeState, or `NULL` if the 'State' field is not needed.
`error` : | return location for error or `NULL`.
Returns : | `TRUE` if the message was correctly parsed, `FALSE` if `error` is set.

### mbim_message_ip_packet_filters_query_new ()

    MbimMessage *       mbim_message_ip_packet_filters_query_new
                                                            (guint32 session_id,
                                                             guint32 packet_filters_count,
                                                             const MbimPacketFilter *const *packet_filters,
                                                             GError **error);

Create a new request for the 'IP Packet Filters' query command in the 'Basic Connect' service.

`session_id` : | the 'SessionId' field, given as a guint32.
`packet_filters_count` : | the 'PacketFiltersCount' field, given as a guint32.
`packet_filters` : | the 'PacketFilters' field, given as an array of MbimPacketFilters.
`error` : | return location for error or `NULL`.
Returns : | a newly allocated MbimMessage, which should be freed with `mbim_message_unref()`.

### mbim_message_ip_packet_filters_set_new ()

    MbimMessage *       mbim_message_ip_packet_filters_set_new
                                                            (guint32 session_id,
                                                             guint32 packet_filters_count,
                                                             const MbimPacketFilter *const *packet_filters,
                                                             GError **error);

Create a new request for the 'IP Packet Filters' set command in the 'Basic Connect' service.

`session_id` : | the 'SessionId' field, given as a guint32.
`packet_filters_count` : | the 'PacketFiltersCount' field, given as a guint32.
`packet_filters` : | the 'PacketFilters' field, given as an array of MbimPacketFilters.
`error` : | return location for error or `NULL`.
Returns : | a newly allocated MbimMessage, which should be freed with `mbim_message_unref()`.

### mbim_message_ip_packet_filters_response_parse ()

    gboolean            mbim_message_ip_packet_filters_response_parse
                                                            (const MbimMessage *message,
                                                             guint32 *session_id,
                                                             guint32 *packet_filters_count,
                                                             MbimPacketFilter ***packet_filters,
                                                             GError **error);

Create a new request for the 'PacketFilters' response command in the 'Basic Connect' service.

`message` : | the MbimMessage.
`session_id` : | return location for a guint32, or `NULL` if the 'SessionId' field is not needed.
`packet_filters_count` : | return location for a guint32, or `NULL` if the 'PacketFiltersCount' field is not needed.
`packet_filters` : | return location for a newly allocated array of MbimPacketFilters, or `NULL` if the 'PacketFilters' field is not needed. Free the returned value with `mbim_packet_filter_array_free()`.
`error` : | return location for error or `NULL`.
Returns : | `TRUE` if the message was correctly parsed, `FALSE` if `error` is set.

### mbim_message_multicarrier_providers_query_new ()

    MbimMessage *       mbim_message_multicarrier_providers_query_new
                                                            (GError **error);

Create a new request for the 'Multicarrier Providers' query command in the 'Basic Connect' service.

`error` : | return location for error or `NULL`.
Returns : | a newly allocated MbimMessage, which should be freed with `mbim_message_unref()`.

### mbim_message_multicarrier_providers_set_new ()

    MbimMessage *       mbim_message_multicarrier_providers_set_new
                                                            (guint32 providers_count,
                                                             const MbimProvider *const *providers,
                                                             GError **error);

Create a new request for the 'Multicarrier Providers' set command in the 'Basic Connect' service.

`providers_count` : | the 'ProvidersCount' field, given as a guint32.
`providers` : | the 'Providers' field, given as an array of MbimProviders.
`error` : | return location for error or `NULL`.
Returns : | a newly allocated MbimMessage, which should be freed with `mbim_message_unref()`.

### mbim_message_multicarrier_providers_response_parse ()

    gboolean            mbim_message_multicarrier_providers_response_parse
                                                            (const MbimMessage *message,
                                                             guint32 *providers_count,
                                                             MbimProvider ***providers,
                                                             GError **error);

Create a new request for the 'Providers' response command in the 'Basic Connect' service.

`message` : | the MbimMessage.
`providers_count` : | return location for a guint32, or `NULL` if the 'ProvidersCount' field is not needed.
`providers` : | return location for a newly allocated array of MbimProviders, or `NULL` if the 'Providers' field is not needed. Free the returned value with `mbim_provider_array_free()`.
`error` : | return location for error or `NULL`.
Returns : | `TRUE` if the message was correctly parsed, `FALSE` if `error` is set.