phone_restriction.h

/*
 * Copyright (c) 2000-2017 Samsung Electronics Co., Ltd All Rights Reserved
 *
 * PROPRIETARY/CONFIDENTIAL
 *
 * This software is the confidential and proprietary information of
 * SAMSUNG ELECTRONICS ("Confidential Information").
 * You shall not disclose such Confidential Information and shall
 * use it only in accordance with the terms of the license agreement
 * you entered into with SAMSUNG ELECTRONICS.
 * SAMSUNG make no representations or warranties about the suitability
 * of the software, either express or implied, including but not
 * limited to the implied warranties of merchantability, fitness for
 * a particular purpose, or non-infringement.
 * SAMSUNG shall not be liable for any damages suffered by licensee as
 * a result of using, modifying or distributing this software or its derivatives.
 */

#ifndef LIBMDM_MDM_PHONE_RESTRICTION_H
#define LIBMDM_MDM_PHONE_RESTRICTION_H

#include <time.h>

#include "mdm_client_type.h"
#include "device_inventory.h"

#ifdef __cplusplus
extern "C" {
#endif


typedef enum {
    MDM_LIMIT_NUMBER_OF_CALLS_BY_DAY =
        0x00000000, 
    MDM_LIMIT_NUMBER_OF_CALLS_BY_WEEK =
        0x00000001, 
    MDM_LIMIT_NUMBER_OF_CALLS_BY_MONTH =
        0x00000002 
} mdm_call_limit_t;

typedef enum {
    MDM_LIMIT_NUMBER_OF_SMS_BY_DAY =
        0x00000000, 
    MDM_LIMIT_NUMBER_OF_SMS_BY_WEEK =
        0x00000001, 
    MDM_LIMIT_NUMBER_OF_SMS_BY_MONTH =
        0x00000002 
} mdm_sms_limit_t;

typedef enum {
    MDM_CALL_TYPE_SMS       = 0, 
    MDM_CALL_TYPE_CALL      = 1, 
    MDM_CALL_TYPE_DATA_CALL = 2  
} mdm_call_type_t;

mdm_status_t mdm_get_emergency_call_only_enabled(void);

mdm_status_t mdm_get_data_call_limit_enabled(void);

mdm_status_t mdm_get_limit_number_of_calls_enabled(void);

mdm_status_t mdm_get_limit_number_of_sms_enabled(void);

mdm_data_t *mdm_get_incoming_call_restriction(int n_all_admin);

mdm_data_t *mdm_get_incoming_sms_restriction(int n_all_admin);

mdm_data_t *mdm_get_outgoing_call_restriction(int n_all_admin);

mdm_data_t *mdm_get_outgoing_sms_restriction(int n_all_admin);

/*
 * @brief API to get the allowed pattern for incoming Call
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Admin can use this API to retrieve the current pattern being used to allowed incoming Call.
 *
 * @code{.c}
    lp_data = mdm_msim_get_sim_ids();
    if (lp_data && lp_data->data) {
        GList *sim_ids_list = g_list_first(lp_data->data);
        for(; sim_ids_list; sim_ids_list = g_list_next(sim_ids_list)){
            mdm_data_t *lp_data = mdm_msim_get_allowed_incoming_call(sim_ids_list->data, FALSE);
            if (lp_data) {
                printf("data : %s", (char *)lp_data->data);
                mdm_free_data(lp_data);
            }
        }
    }
 *
 * @endcode
 *
 * @param[in]   simid       Sim identifier
 * @param[in]   n_all_admin True to get a composition of all allows from all admins, false to get a allows pattern from
 the calling admin
 *
 * @return #mdm_data_t * on success, NULL on error
 *
 * @see mdm_msim_add_allowed_incoming_call
 *
 */
mdm_data_t *mdm_msim_get_allowed_incoming_call(const char *simid, int n_all_admin);

/*
 * @brief API to get the allowed pattern for outgoing calls.
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Admin can use this API to retrieve the current pattern being used to allowed outgoing Call.
 *
 * @code{.c}
    lp_data = mdm_msim_get_sim_ids();
    if (lp_data && lp_data->data) {
        GList *sim_ids_list = g_list_first(lp_data->data);
        for(; sim_ids_list; sim_ids_list = g_list_next(sim_ids_list)){
            mdm_data_t *lp_data = mdm_msim_get_allowed_outgoing_call(sim_ids_list->data, FALSE);
            if (lp_data) {
                printf("data : %s", (char *)lp_data->data);
                mdm_free_data(lp_data);
            }
        }
    }
 *
 * @endcode
 *
 * @param[in]   simid       Sim card id
 * @param[in]   n_all_admin True to get a composition of all allows from all admins, false to get a allows pattern from
 the calling admin
 *
 * @return #mdm_data_t * on success, NULL on error
 *
 * @see mdm_msim_add_allowed_outgoing_call
 *
 */
mdm_data_t *mdm_msim_get_allowed_outgoing_call(const char *simid, int n_all_admin);

/*
 * @brief API to get the allowed pattern for incoming SMS.
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Admin can use this API to retrieve the current pattern being used to allowed incoming SMS.
 *
 * @code{.c}
    lp_data = mdm_msim_get_sim_ids();
    if (lp_data && lp_data->data) {
        GList *sim_ids_list = g_list_first(lp_data->data);
        for(; sim_ids_list; sim_ids_list = g_list_next(sim_ids_list)){
            mdm_data_t *lp_data = mdm_msim_get_allowed_incoming_sms(sim_ids_list->data, FALSE);
            if (lp_data) {
                printf("data : %s", (char *)lp_data->data);
                mdm_free_data(lp_data);
            }
        }
    }
 *
 * @endcode
 * @param[in] simid         Sim card id
 * @param[in] n_all_admin   True to get a composition of all allows from all admins, false to get a allows pattern from
 the calling admin.
 *
 * @return #mdm_data_t * on success, NULL on error
 *
 * @see mdm_msim_add_allowed_incoming_sms
 *
 */
mdm_data_t *mdm_msim_get_allowed_incoming_sms(const char *simid, int n_all_admin);

/*
 * @brief API to get the allowed pattern for outgoing SMS
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Admin can use this API to retrieve the current pattern being used to allowed outgoing SMS.
 *
 * @code{.c}
    lp_data = mdm_msim_get_sim_ids();
    if (lp_data && lp_data->data) {
        GList *sim_ids_list = g_list_first(lp_data->data);
        for(; sim_ids_list; sim_ids_list = g_list_next(sim_ids_list)){
            mdm_data_t *lp_data = mdm_msim_get_allowed_outgoing_sms(sim_ids_list->data, FALSE);
            if (lp_data) {
                printf("data : %s", (char *)lp_data->data);
                mdm_free_data(lp_data);
            }
        }
    }
 *
 * @endcode
 *
 * @param[in]   simid       Sim card id
 * @param[in]   n_all_admin True to get a composition of all allows from all admins, false to get a allows pattern from
 the calling admin.
 *
 * @return #mdm_data_t * on success, NULL on error
 *
 * @see mdm_msim_add_allowed_outgoing_sms
 *
 */
mdm_data_t *mdm_msim_get_allowed_outgoing_sms(const char *simid, int n_all_admin);

mdm_result_t mdm_get_limit_of_data_calls(time_t *p_date_set, time_t *p_period, size_t *p_send_limit,
                                         size_t *p_recv_limit);

mdm_result_t mdm_get_limit_of_incoming_calls(mdm_call_limit_t type, unsigned int *p_value);

mdm_result_t mdm_get_limit_of_incoming_sms(mdm_sms_limit_t type, unsigned int *p_value);

mdm_result_t mdm_get_limit_of_outgoing_calls(mdm_call_limit_t type, unsigned int *p_value);

mdm_result_t mdm_get_limit_of_outgoing_sms(mdm_sms_limit_t type, unsigned int *p_value);

mdm_result_t mdm_enable_limit_number_of_calls(mdm_status_t status);

mdm_result_t mdm_enable_limit_number_of_sms(mdm_status_t status);

mdm_result_t mdm_enable_data_call_limit(mdm_status_t status);

mdm_result_t mdm_enable_emergency_call_only(mdm_status_t status);

mdm_result_t mdm_add_incoming_call_restriction(char *p_pattern);

mdm_result_t mdm_add_incoming_sms_restriction(char *p_pattern);

mdm_result_t mdm_add_outgoing_call_restriction(char *p_pattern);

mdm_result_t mdm_add_outgoing_sms_restriction(char *p_pattern);

/*
 * @brief API to add a restriction pattern to the admin restriction pattern set for incoming calls
 *
 * @since_mdm 1.0.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * This API adds (concatenates) the provided allowed pattern to the allowed pattern set of the admin for incoming calls.
 *
 * @code{.c}
    // previous patterns will remain and the new pattern will be added
    lp_data = mdm_msim_get_sim_ids();
    if (lp_data && lp_data->data) {
        GList *sim_ids_list = g_list_first(lp_data->data);
        for(; sim_ids_list; sim_ids_list = g_list_next(sim_ids_list)){
            mdm_result_t ret = mdm_msim_add_allowed_incoming_call(sim_ids_list->data, ".*");
            if (ret != MDM_RESULT_SUCCESS) {
                // function error
            } else {
                // function success
            }
        }
    }
 *
 * @endcode
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.phonerestriction
 *
 * @param[in]   id          SIM card id
 * @param[in]   p_pattern   The allowed pattern to be matched against the incoming call number
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @par Permission:
 * Usage of this API is restricted to registered clients only.
 *
 * @see mdm_msim_remove_allowed_incoming_call
 *
 */
mdm_result_t mdm_msim_add_allowed_incoming_call(const char *id, const char *p_pattern);

/*
 * @brief API to add a restriction pattern to the admin restriction pattern set for incoming calls
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * This API adds (concatenates) the provided allowed pattern to the allowed pattern set of the admin for incoming calls.
 *
 * @code{.c}
    // previous patterns will remain and the new pattern will be added
    lp_data = mdm_msim_get_sim_ids();
    if (lp_data && lp_data->data) {
        GList *sim_ids_list = g_list_first(lp_data->data);
        for(; sim_ids_list; sim_ids_list = g_list_next(sim_ids_list)){
            mdm_result_t ret = mdm_msim_add_allowed_outgoing_call(sim_ids_list->data, ".*");
            if (ret != MDM_RESULT_SUCCESS) {
                // function error
            } else {
                // function success
            }
        }
    }
 *
 * @endcode
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.phonerestriction
 *
 * @param[in]   id          SIM card id
 * @param[in]   p_pattern   The allowed pattern to be matched against the incoming call number
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @par Permission:
 * Usage of this API is restricted to registered clients only.
 *
 * @see mdm_msim_remove_allowed_outgoing_call
 *
 */
mdm_result_t mdm_msim_add_allowed_outgoing_call(const char *id, const char *p_pattern);

/*
 * @brief API to add a restriction pattern to the admin restriction pattern set for incoming calls
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * This API adds (concatenates) the provided allowed pattern to the allowed pattern set of the admin for incoming calls.
 *
 * @code{.c}
    // previous patterns will remain and the new pattern will be added
    lp_data = mdm_msim_get_sim_ids();
    if (lp_data && lp_data->data) {
        GList *sim_ids_list = g_list_first(lp_data->data);
        for(; sim_ids_list; sim_ids_list = g_list_next(sim_ids_list)){
            mdm_result_t ret = mdm_msim_add_allowed_incoming_sms(sim_ids_list->data, ".*");
            if (ret != MDM_RESULT_SUCCESS) {
                // function error
            } else {
                // function success
            }
        }
    }
 *
 * @endcode
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.phonerestriction
 *
 * @param[in]   id          SIM card id
 * @param[in]   p_pattern   The allowed pattern to be matched against the incoming call number
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @par Permission:
 * Usage of this API is restricted to registered clients only.
 *
 * @see mdm_msim_remove_allowed_outgoing_call
 *
 */
mdm_result_t mdm_msim_add_allowed_incoming_sms(const char *id, const char *p_pattern);

/*
 * @brief API to add a restriction pattern to the admin restriction pattern set for incoming calls
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * This API adds (concatenates) the provided allowed pattern to the allowed pattern set of the admin for incoming calls.
 *
 * @code{.c}
    // previous patterns will remain and the new pattern will be added
    lp_data = mdm_msim_get_sim_ids();
    if (lp_data && lp_data->data) {
        GList *sim_ids_list = g_list_first(lp_data->data);
        for(; sim_ids_list; sim_ids_list = g_list_next(sim_ids_list)){
            mdm_result_t ret = mdm_msim_add_allowed_outgoing_sms(sim_ids_list->data, ".*");
            if (ret != MDM_RESULT_SUCCESS) {
                // function error
            } else {
                // function success
            }
        }
    }
 *
 * @endcode
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.phonerestriction
 *
 * @param[in]   id          SIM card id
 * @param[in]   p_pattern   The allowed pattern to be matched against the incoming call number
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @par Permission:
 * Usage of this API is restricted to registered clients only.
 *
 * @see mdm_msim_remove_allowed_outgoing_call
 *
 */
mdm_result_t mdm_msim_add_allowed_outgoing_sms(const char *id, const char *p_pattern);

mdm_result_t mdm_remove_incoming_call_restriction(void);

mdm_result_t mdm_remove_incoming_sms_restriction(void);

mdm_result_t mdm_remove_outgoing_call_restriction(void);

mdm_result_t mdm_remove_outgoing_sms_restriction(void);

mdm_result_t mdm_reset_call_limit_count(void);

/*
 * @brief API to check if phone number is restricted in sms/call/data
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * This method checks if phone number is on white list and if not then on black list.
 *
 * @code{.c}
 *    lp_data = mdm_msim_get_sim_ids();
    if (lp_data && lp_data->data) {
        GList *sim_ids_list = g_list_first(lp_data->data);
        for(; sim_ids_list; sim_ids_list = g_list_next(sim_ids_list)){
            mdm_status_t ret = mdm_msim_is_number_restricted(sim_ids_list->data, MDM_DIRECTION_INCOMING,
 MDM_CALL_TYPE_SMS, "666000666");
            if (ret == MDM_ENABLED) {
                // enabled
            } else {
                // disabled
            }
        }
 *
 * @endcode
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.phonerestriction
 *
 * @param[in] sim_id Sim identifier
 * @param[in] direction @see mdm_direction_t
 * @param[in] call_type @see mdm_call_type_t
 * @param[in] msisdn phone number to check
 *
 * @return #mdm_status_t : Whether phone number is restricred
 *
 * @retval #MDM_RESTRICTED Phone number is restricted
 * @retval #MDM_ALLOWED Phone number is allowed
 * @retval #MDM_STATUS_ERROR On Fail
 *
 * @par Permission:
 * Usage of this API is restricted to registered clients only.
 *
 * @see
 *
 */
mdm_status_t mdm_msim_is_number_restricted(const char *sim_id, mdm_direction_t direction, mdm_call_type_t call_type,
                                           const char *msisdn);

mdm_result_t mdm_reset_data_call_limit_count(void);

mdm_result_t mdm_reset_sms_limit_count(void);

mdm_result_t mdm_set_incoming_call_restriction(char *p_pattern);

mdm_result_t mdm_set_incoming_sms_restriction(char *p_pattern);

mdm_result_t mdm_set_limit_of_data_calls(time_t period, size_t sent_limit, size_t recv_limit);

mdm_result_t mdm_set_limit_of_incoming_calls(unsigned int limitbyday, unsigned int limitbyweek,
                                             unsigned int limitbymonth);

mdm_result_t mdm_set_limit_of_incoming_sms(unsigned int limitbyday, unsigned int limitbyweek,
                                           unsigned int limitbymonth);

mdm_result_t mdm_set_limit_of_outgoing_calls(unsigned int limitbyday, unsigned int limitbyweek,
                                             unsigned int limitbymonth);

mdm_result_t mdm_set_limit_of_outgoing_sms(unsigned int limitbyday, unsigned int limitbyweek,
                                           unsigned int limitbymonth);

mdm_result_t mdm_set_outgoing_call_restriction(char *p_pattern);

mdm_result_t mdm_set_outgoing_sms_restriction(char *p_pattern);

/* For dual sim begin */

/*
 * @brief API to add a restriction pattern to the admin restriction pattern set for incoming calls
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * This API adds (concatenates) the provided restriction pattern to the restriction pattern set of the admin for
 incoming calls.
 *
 * @code{.c}
    // previous patterns will remain and the new pattern will be added
    mdm_result_t ret = mdm_msim_add_incoming_call_restriction("SIM1", ".*");
    if (ret != MDM_RESULT_SUCCESS) {
        // function error
    } else {
        // function success
    }
 *
 * @endcode
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.phonerestriction
 *
 * @param[in]       id          Id that pattern is applied for.
 * @param[in]       p_pattern   The restriction pattern to be matched against the incoming call number.
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @par Permission:
 * Usage of this API is restricted to registered clients only.
 *
 * @see mdm_msim_remove_incoming_call_restriction
 *
 */
mdm_result_t mdm_msim_add_incoming_call_restriction(const char *id, char *p_pattern);

/*
 * @brief API to add a restriction pattern to the admin restriction pattern set for incoming SMSs
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * This API adds (concatenates) the provided restriction pattern to the restriction pattern set of the admin for
 incoming SMSs.
 *
 * @code{.c}
    // previous patterns will remain and the new pattern will be added
    mdm_result_t ret = mdm_msim_add_incoming_sms_restriction("SIM1", ".*");
    if (ret != MDM_RESULT_SUCCESS) {
        // function error
    } else {
        // function success
    }
 *
 * @endcode
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.phonerestriction
 *
 * @param[in]       id          Id that pattern is applied for.
 * @param[in]       p_pattern   The restriction pattern to be matched against the incoming sms number.
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @par Permission:
 * Usage of this API is restricted to registered clients only.
 *
 * @see mdm_msim_remove_incoming_sms_restriction
 *
 */
mdm_result_t mdm_msim_add_incoming_sms_restriction(const char *id, char *p_pattern);

/*
 * @brief API to add a restriction pattern to the admin restriction pattern set for outgoing calls
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * This API adds (concatenates) the provided restriction pattern to the restriction pattern set of the admin for
 outgoing calls.
 *
 * @code{.c}
    // previous patterns will remain and the new pattern will be added
    mdm_result_t ret = mdm_msim_add_outgoing_call_restriction("SIM1", ".*");
    if (ret != MDM_RESULT_SUCCESS) {
        // function error
    } else {
        // function success
    }
 *
 * @endcode
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.phonerestriction
 *
 * @param[in]       id          Id that pattern is applied for.
 * @param[in]       p_pattern   The restriction pattern to be matched against the outgoing call number.
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @par Permission:
 * Usage of this API is restricted to registered clients only.
 *
 * @see mdm_msim_remove_outgoing_call_restriction
 *
 */
mdm_result_t mdm_msim_add_outgoing_call_restriction(const char *id, char *p_pattern);

/*
 * @brief API to add a restriction pattern to the admin restriction pattern set for outgoing SMSs
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * This API adds (concatenates) the provided restriction pattern to the restriction pattern set of the admin for
 outgoing SMSs.
 *
 * @code{.c}
    // previous patterns will remain and the new pattern will be added
    mdm_result_t ret = mdm_msim_add_outgoing_sms_restriction("SIM1", ".*");
    if (ret != MDM_RESULT_SUCCESS) {
        // function error
    } else {
        // function success
    }
 *
 * @endcode
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.phonerestriction
 *
 * @param[in]       id          Id that pattern is applied for
 * @param[in]       p_pattern   The restriction pattern to be matched against the outgoing sms number
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @par Permission:
 * Usage of this API is restricted to registered clients only.
 *
 * @see mdm_msim_remove_incoming_call_restriction
 *
 */
mdm_result_t mdm_msim_add_outgoing_sms_restriction(const char *id, char *p_pattern);

/*
 * @brief API to set a restriction pattern to be matched by incoming call numbers
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * This API overrides any pattern previously set by the admin for incoming calls.
 *
 * @code{.c}
    mdm_result_t ret = mdm_msim_set_incoming_call_restriction("SIM1", ".*");
    if (ret != MDM_RESULT_SUCCESS) {
        // failed setting count
    } else {
        // success setting count
    }
 *
 * @endcode
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.phonerestriction
 *
 * @param[in]       id          Id that pattern is applied for.
 * @param[in]       p_pattern   The restriction pattern to be matched against the incoming call number.
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @par Permission:
 * Usage of this API is restricted to registered clients only.
 *
 * @see mdm_msim_get_incoming_call_restriction
 *
 */
mdm_result_t mdm_msim_set_incoming_call_restriction(const char *id, char *p_pattern);

/*
 * @brief API to set a restriction pattern to be matched by incoming SMSs numbers
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * This API overrides any pattern previously set by the admin for incoming SMSs.
 *
 * @code{.c}
    mdm_result_t ret = mdm_msim_set_incoming_sms_restriction("SIM1", ".*");
    if (ret != MDM_RESULT_SUCCESS) {
        // failed setting count
    } else {
        // success setting count
    }
 *
 * @endcode
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.phonerestriction
 *
 * @param[in]       id          Id that pattern is applied for.
 * @param[in]       p_pattern   The restriction pattern to be matched against the incoming sms number.
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @par Permission:
 * Usage of this API is restricted to registered clients only.
 *
 * @see mdm_msim_get_incoming_sms_restriction
 *
 */
MDM_DEPRECATED_API mdm_result_t mdm_msim_set_incoming_sms_restriction(const char *id, char *p_pattern);

/*
 * @brief API to set a restriction pattern to be matched by outgoing call numbers
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * This API overrides any pattern previously set by the admin for outgoing calls.
 *
 * @code{.c}
    mdm_result_t ret = mdm_msim_set_outgoing_call_restriction("SIM1",
 "(?![1]?[\\-]?800[\\-]?[0-9]{3}[\\-]?[0-9]{4}$).*");
    if (ret != MDM_RESULT_SUCCESS) {
        // failed setting count
    } else {
        // success setting count
    }
 *
 * @endcode
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.phonerestriction
 *
 * @param[in]       id          Id that pattern is applied for.
 * @param[in]       p_pattern   The restriction pattern to be matched against the outgoing call number.
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @par Permission:
 * Usage of this API is restricted to registered clients only.
 *
 * @see mdm_msim_get_outgoing_call_restriction
 *
 */
mdm_result_t mdm_msim_set_outgoing_call_restriction(const char *id, char *p_pattern);

/*
 * @brief API to set a restriction pattern to be matched by outgoing sms numbers
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * This method overrides any previously set pattern in database or add a new one if none exist
 *
 * @code{.c}
    mdm_result_t ret = mdm_msim_set_outgoing_sms_restriction("SIM1",
 "(?![1]?[\\-]?800[\\-]?[0-9]{3}[\\-]?[0-9]{4}$).*");
    if (ret != MDM_RESULT_SUCCESS) {
        // failed setting count
    } else {
        // success setting count
    }
 *
 * @endcode
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.phonerestriction
 *
 * @param[in]       id          Id that pattern is applied for.
 * @param[in]       p_pattern   The restriction pattern to be matched against the outgoing sms number.
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @par Permission:
 * Usage of this API is restricted to registered clients only.
 *
 * @see mdm_msim_get_outgoing_sms_restriction2
 *
 */
MDM_DEPRECATED_API mdm_result_t mdm_msim_set_outgoing_sms_restriction(const char *id, char *p_pattern);

/*
 * @brief API to get the restriction pattern for incoming calls
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Admin can use this API to retrieve the current pattern being used to restrict incoming calls.
 *
 * @code{.c}
    mdm_data_t *lp_data = mdm_msim_get_incoming_call_restriction("SIM1", FALSE);
    if (lp_data) {
        printf("data : %s", (char *)lp_data->data);
        mdm_free_data(lp_data);
    }
 *
 * @endcode
 *
 * @param[in] id            SIM card id. Check mdm_msim_get_sim_ids() for available SIM card ids.
 * @param[in] n_all_admin   True to get a composition of all restrictions from all admins, false to get a restriction
 pattern from the calling admin.
 *
 * @return #mdm_status_t : Current mode of operation, one of #MDM_ALLOWED or #MDM_RESTRICTED
 *
 * @see mdm_msim_set_incoming_call_restriction
 *
 */
mdm_data_t *mdm_msim_get_incoming_call_restriction(const char *id, int n_all_admin);

/*
 * @brief API to get the restriction pattern for incoming SMS
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Admin can use this API to retrieve the current pattern being used to restrict incoming SMS.
 *
 * @code{.c}
    mdm_data_t *lp_data = mdm_msim_get_incoming_call_restriction("SIM1", FALSE);
    if (lp_data) {
        printf("data : %s", (char *)lp_data->data);
        mdm_free_data(lp_data);
    }
 *
 * @endcode
 *
 * @param[in]       id          Id of sim
 * @param[in]       n_all_admin True to get a composition of all restrictions from all admins, false to get a
 restriction pattern from the calling admin
 *
 * @return #mdm_data_t * on success, NULL on error
 *
 * @see mdm_msim_set_incoming_sms_restriction
 *
 */
mdm_data_t *mdm_msim_get_incoming_sms_restriction(const char *id, int n_all_admin);

/*
 * @brief API to get the restriction pattern for outgoing calls
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Admin can use this API to retrieve the current pattern being used to restrict outgoing calls.
 *
 * @code{.c}
    mdm_data_t *lp_data = mdm_msim_get_outgoing_call_restriction("SIM1", FALSE);
    if (lp_data) {
        printf("data : %s", (char *)lp_data->data);
        mdm_free_data(lp_data);
    }
 *
 * @endcode
 *
 * @param[in]       id          Id of sim
 * @param[in]       n_all_admin True to get a composition of all restrictions from all admins, false to get a
 restriction pattern from the calling admin.
 *
 * @return #mdm_data_t * on success, NULL on error
 *
 * @see mdm_msim_set_outgoing_call_restriction
 *
 */
mdm_data_t *mdm_msim_get_outgoing_call_restriction(const char *id, int n_all_admin);

/*
 * @brief API to get the restriction pattern for outgoing SMS
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Admin can use this API to retrieve the current pattern being used to restrict outgoing SMS.
 *
 * @code{.c}
    mdm_data_t *lp_data = mdm_msim_get_outgoing_sms_restriction("SIM1", FALSE);
    if (lp_data) {
        printf("data : %s", (char *)lp_data->data);
        mdm_free_data(lp_data);
    }
 *
 * @endcode
 *
 * @param[in]       id          Id of sim
 * @param[in]       n_all_admin True to get a composition of all restrictions from all admins, false to get a
 restriction pattern from the calling admin.
 *
 * @return #mdm_data_t * on success, NULL on error
 *
 * @see mdm_msim_set_outgoing_sms_restriction
 *
 */
mdm_data_t *mdm_msim_get_outgoing_sms_restriction(const char *id, int n_all_admin);

/*
 * @brief API to remove the restriction pattern for incoming calls set by the calling admin
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * This method removes the pattern set by the caller admin for incoming calls restriction
 *
 * @code{.c}
    mdm_result_t ret = mdm_msim_remove_incoming_call_restriction("SIM1");
    if (ret != MDM_RESULT_SUCCESS) {
        // failed setting count
    } else {
        // success setting count
    }
 *
 * @endcode
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.phonerestriction
 *
 * @param[in]      id       id of sim restrictions are deleted for
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @par Permission:
 * Usage of this API is restricted to registered clients only.
 *
 * @see mdm_msim_add_incoming_call_restriction
 *
 */
mdm_result_t mdm_msim_remove_incoming_call_restriction(const char *id);

/*
 * @brief API to remove the restriction pattern for incoming SMSs set by the calling admin
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * This method removes the pattern set by the caller admin for incoming SMS restriction
 *
 * @code{.c}
    mdm_result_t ret = mdm_msim_remove_incoming_sms_restriction("SIM1");
    if (ret != MDM_RESULT_SUCCESS) {
        // failed setting count
    } else {
        // success setting count
    }
 *
 * @endcode
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.phonerestriction
 *
 * @param[in]       id      Id of sim restrictions are deleted for
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @par Permission:
 * Usage of this API is restricted to registered clients only.
 *
 * @see mdm_msim_add_incoming_sms_restriction
 *
 */
mdm_result_t mdm_msim_remove_incoming_sms_restriction(const char *id);

/*
 * @brief API to remove the restriction pattern for outgoing calls set by the calling admin
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * This method removes the pattern set by the caller admin for outgoing calls restriction
 *
 * @code{.c}
    mdm_result_t ret = mdm_msim_remove_outgoing_call_restriction("SIM1");
    if (ret != MDM_RESULT_SUCCESS) {
        // failed setting count
    } else {
        // success setting count
    }
 *
 * @endcode
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.phonerestriction
 *
 * @param[in]   id SIM card id. Check mdm_msim_get_sim_ids() for available SIM card ids.
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @par Permission:
 * Usage of this API is restricted to registered clients only.
 *
 * @see mdm_msim_add_outgoing_call_restriction
 *
 */
mdm_result_t mdm_msim_remove_outgoing_call_restriction(const char *id);

/*
 * @brief API to remove the allowing pattern for incoming Calls set by the calling admin
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * This method removes the pattern set by the caller admin for incoming Calls allowed
 *
 * @code{.c}
    mdm_result_t ret = mdm_msim_remove_allowed_incoming_call("SIM1");
    if (ret != MDM_RESULT_SUCCESS) {
        // failed setting count
    } else {
        // success setting count
    }
 *
 * @endcode
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.phonerestriction
 *
 * @param[in] id SIM card id. Check mdm_msim_get_sim_ids() for available SIM card ids.
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @par Permission:
 * Usage of this API is restricted to registered clients only.
 *
 * @see mdm_msim_add_outgoing_sms_restriction
 *
 */
mdm_result_t mdm_msim_remove_allowed_incoming_call(const char *id);

/*
 * @brief API to remove the restriction pattern for outgoing SMSs set by the calling admin
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * This method removes the pattern set by the caller admin for outgoing SMSs restriction
 *
 * @code{.c}
    mdm_result_t ret = mdm_msim_remove_outgoing_sms_restriction("SIM1");
    if (ret != MDM_RESULT_SUCCESS) {
        // failed setting count
    } else {
        // success setting count
    }
 *
 * @endcode
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.phonerestriction
 *
 * @param[in] id SIM card id. Check mdm_msim_get_sim_ids() for available SIM card ids.
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @par Permission:
 * Usage of this API is restricted to registered clients only.
 *
 * @see mdm_msim_add_outgoing_sms_restriction
 *
 */
mdm_result_t mdm_msim_remove_outgoing_sms_restriction(const char *id);

/*
 * @brief API to remove the allowing pattern for outgoing Calls set by the calling admin
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * This method removes the pattern set by the caller admin for outgoing Calls allowed
 *
 * @code{.c}
    mdm_result_t ret = mdm_msim_remove_allowed_outgoing_call("SIM1");
    if (ret != MDM_RESULT_SUCCESS) {
        // failed setting count
    } else {
        // success setting count
    }
 *
 * @endcode
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.phonerestriction
 *
 * @param[in] id SIM card id. Check mdm_msim_get_sim_ids() for available SIM card ids.
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @par Permission:
 * Usage of this API is restricted to registered clients only.
 *
 * @see mdm_msim_add_outgoing_sms_restriction
 *
 */
mdm_result_t mdm_msim_remove_allowed_outgoing_call(const char *id);

/*
 * @brief API to remove the allowing pattern for incoming SMSs set by the calling admin
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * This method removes the pattern set by the caller admin for incoming SMSs allowed
 *
 * @code{.c}
    mdm_result_t ret = mdm_msim_remove_allowed_incoming_sms("SIM1");
    if (ret != MDM_RESULT_SUCCESS) {
        // failed setting count
    } else {
        // success setting count
    }
 *
 * @endcode
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.phonerestriction
 *
 * @param[in] id SIM card id. Check mdm_msim_get_sim_ids() for available SIM card ids.
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @par Permission:
 * Usage of this API is restricted to registered clients only.
 *
 * @see mdm_msim_add_outgoing_sms_restriction
 *
 */
mdm_result_t mdm_msim_remove_allowed_incoming_sms(const char *id);

/*
 * @brief API to remove the allowing pattern for outgoing SMSs set by the calling admin
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * This method removes the pattern set by the caller admin for outgoing SMSs allowed
 *
 * @code{.c}
    mdm_result_t ret = mdm_msim_remove_allowed_outgoing_sms("SIM1");
    if (ret != MDM_RESULT_SUCCESS) {
        // failed setting count
    } else {
        // success setting count
    }
 *
 * @endcode
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.phonerestriction
 *
 * @param[in] id SIM card id. Check mdm_msim_get_sim_ids() for available SIM card ids.
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @par Permission:
 * Usage of this API is restricted to registered clients only.
 *
 * @see mdm_msim_add_outgoing_sms_restriction
 *
 */
mdm_result_t mdm_msim_remove_allowed_outgoing_sms(const char *id);

/*
 * @brief API to get the restriction pattern for incoming calls
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Admin can use this API to retrieve the current pattern being used to restrict incoming calls.
 *
 * @code{.c}
    mdm_data_t *lp_data = mdm_msim_get_incoming_call_restriction("SIM1", FALSE);
    if (lp_data) {
        printf("data : %s", (char *)lp_data->data);
        mdm_free_data(lp_data);
    }
 *
 * @endcode
 *
 * @param[in] id           SIM card id. Check mdm_msim_get_sim_ids() for available SIM card ids.
 * @param[in] n_all_admin  true to get a composition of all restrictions from all admins, false to get a restriction
 pattern from the calling admin
 *
 * @return #mdm_status_t : Current mode of operation, one of #MDM_ALLOWED or #MDM_RESTRICTED
 *
 * @see mdm_msim_set_incoming_call_restriction
 *
 */
mdm_data_t *mdm_msim_get_incoming_call_restriction(const char *id, int n_all_admin);

/*
 * @brief API to get the restriction pattern for incoming SMS
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Admin can use this API to retrieve the current pattern being used to restrict incoming SMS.
 *
 * @code{.c}
    mdm_data_t *lp_data = mdm_msim_get_incoming_call_restriction("SIM1", FALSE);
    if (lp_data) {
        printf("data : %s", (char *)lp_data->data);
        mdm_free_data(lp_data);
    }
 *
 * @endcode
 *
 * @param[in]       id          Id of sim
 * @param[in]       n_all_admin True to get a composition of all restrictions from all admins, false to get a
 restriction pattern from the calling admin
 *
 * @return #mdm_data_t * on success, NULL on error
 *
 * @see mdm_msim_set_incoming_sms_restriction
 *
 */
mdm_data_t *mdm_msim_get_incoming_sms_restriction(const char *id, int n_all_admin);

/*
 * @brief API to get the restriction pattern for outgoing calls
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Admin can use this API to retrieve the current pattern being used to restrict outgoing calls.
 *
 * @code{.c}
    mdm_data_t *lp_data = mdm_msim_get_outgoing_call_restriction("SIM1", FALSE);
    if (lp_data) {
        printf("data : %s", (char *)lp_data->data);
        mdm_free_data(lp_data);
    }
 *
 * @endcode
 *
 * @param[in]       id          Id of sim
 * @param[in]       n_all_admin True to get a composition of all restrictions from all admins, false to get a
 restriction pattern from the calling admin.
 *
 * @return #mdm_data_t * on success, NULL on error
 *
 * @see mdm_msim_set_outgoing_call_restriction
 *
 */
mdm_data_t *mdm_msim_get_outgoing_call_restriction(const char *id, int n_all_admin);

/*
 * @brief API to get the restriction pattern for outgoing SMS
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Admin can use this API to retrieve the current pattern being used to restrict outgoing SMS.
 *
 * @code{.c}
    mdm_data_t *lp_data = mdm_msim_get_outgoing_sms_restriction("SIM1", FALSE);
    if (lp_data) {
        printf("data : %s", (char *)lp_data->data);
        mdm_free_data(lp_data);
    }
 *
 * @endcode
 *
 * @param[in]       id          Id of sim
 * @param[in]       n_all_admin True to get a composition of all restrictions from all admins, false to get a
 restriction pattern from the calling admin.
 *
 * @return #mdm_data_t * on success, NULL on error
 *
 * @see mdm_msim_set_outgoing_sms_restriction
 *
 */
mdm_data_t *mdm_msim_get_outgoing_sms_restriction(const char *id, int n_all_admin);

/*
 * @brief API to remove the restriction pattern for incoming calls set by the calling admin
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * This method removes the pattern set by the caller admin for incoming calls restriction
 *
 * @code{.c}
    mdm_result_t ret = mdm_msim_remove_incoming_call_restriction("SIM1");
    if (ret != MDM_RESULT_SUCCESS) {
        // failed setting count
    } else {
        // success setting count
    }
 *
 * @endcode
 *
 * @param[in]       id      Id of sim restrictions are deleted for
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.phonerestriction
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @par Permission:
 * Usage of this API is restricted to registered clients only.
 *
 * @see mdm_msim_add_incoming_call_restriction
 *
 */
mdm_result_t mdm_msim_remove_incoming_call_restriction(const char *id);

/*
 * @brief API to remove the restriction pattern for incoming SMSs set by the calling admin
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * This method removes the pattern set by the caller admin for incoming SMS restriction
 *
 * @code{.c}
    mdm_result_t ret = mdm_msim_remove_incoming_sms_restriction("SIM1");
    if (ret != MDM_RESULT_SUCCESS) {
        // failed setting count
    } else {
        // success setting count
    }
 *
 * @endcode
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.phonerestriction
 *
 * @param[in] id id of sim restrictions are deleted for
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @par Permission:
 * Usage of this API is restricted to registered clients only.
 *
 * @see mdm_msim_add_incoming_sms_restriction
 *
 */
mdm_result_t mdm_msim_remove_incoming_sms_restriction(const char *id);

/*
 * @brief API to remove the restriction pattern for outgoing calls set by the calling admin.
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * This method removes the pattern set by the caller admin for outgoing calls restriction
 *
 * @code{.c}
    mdm_result_t ret = mdm_msim_remove_outgoing_call_restriction("SIM1");
    if (ret != MDM_RESULT_SUCCESS) {
        // failed setting count
    } else {
        // success setting count
    }
 *
 * @endcode
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.phonerestriction
 *
 * @param[in] id Id of sim restrictions are deleted for
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @par Permission:
 * Usage of this API is restricted to registered clients only.
 *
 * @see mdm_msim_add_outgoing_call_restriction
 *
 */
mdm_result_t mdm_msim_remove_outgoing_call_restriction(const char *id);

/*
 * @brief API to remove the restriction pattern for outgoing SMSs set by the calling admin
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * This method removes the pattern set by the caller admin for outgoing SMSs restriction
 *
 * @code{.c}
    mdm_result_t ret = mdm_msim_remove_outgoing_sms_restriction("SIM1");
    if (ret != MDM_RESULT_SUCCESS) {
        // failed setting count
    } else {
        // success setting count
    }
 *
 * @endcode
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.phonerestriction
 *
 * @param[in] id SIM card id. Check mdm_msim_get_sim_ids() for available SIM card ids.
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @par Permission:
 * Usage of this API is restricted to registered clients only.
 *
 * @see mdm_msim_add_outgoing_sms_restriction
 *
 */
mdm_result_t mdm_msim_remove_outgoing_sms_restriction(const char *id);

/*
 * @brief API to enable or disable emergency calls only on device
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * If enabled, only emergency will be allowed on device. All other calls will be blocked.
 *
 * @code{.c}
    mdm_result_t ret = mdm_msim_enable_emergency_call_only("SIM1", TRUE);
    if (ret != MDM_RESULT_SUCCESS) {
        // function error
    } else {
        // function success
    }
 *
 * @endcode
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.phonerestriction
 *
 * @param[in]       id      SIM id.
 * @param[in]       status  Only emergency calls
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @par Permission:
 * Usage of this API is restricted to registered clients only.
 *
 * @see mdm_msim_get_emergency_call_only_enabled
 *
 */
mdm_result_t mdm_msim_enable_emergency_call_only(const char *id, mdm_status_t status);

/*
 * @brief API to check if only emergency calls are allowed on device
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Admin can check if the emergency call is enabled on the device. If enabled, only emergency will be allowed. All other
 calls will be blocked.
 *
 * @code{.c}
    mdm_status_t ret = mdm_msim_get_emergency_call_only_enabled("SIM1");
    if (ret != MDM_STATUS_ERROR) {
        if (ret == MDM_TRUE) {
            // feature enabled
        } else {
            // feature disabled
        }
    } else {
        // function error
    }
 *
 * @endcode
 *
 * @return #mdm_status_t : Current mode of operation, one of #MDM_TRUE or #MDM_FALSE
 *
 * @see mdm_enable_emergency_call_only
 *
 */
mdm_status_t mdm_msim_get_emergency_call_only_enabled(const char *id);

/*
 * @brief API to enable/disable user's possibility to change voice calls and messages assignment to the specified SIM slot.
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * This function can be called by an admin to enable/disable possibility of change the assignment of voice calls and
 messages.
 * When restricted user is disallowed to change this assignment to the specified SIM slot.
 *
 * @code{.c}
 *
    mdm_result_t ret = mdm_msim_allow_user_assign_voice_calls_and_messages_to_sim("SIM1", MDM_RESTRICTED);

    if (ret == MDM_RESULT_SUCCESS) {
        // user is disallowed to set assignment to the specified SIM slot
    } else {
        // function error
    }
 *
 * @endcode
 *
 * @param[in]   id  SIM slot ID
 * @param[in]   status
 *               #MDM_ALLOWED      = 0,
 *               #MDM_RESTRICTED   = 1,
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @see mdm_msim_is_user_allowed_assign_voice_calls_and_messages_to_sim
 *
 */
mdm_result_t mdm_msim_allow_user_assign_voice_calls_and_messages_to_sim(const char *id, mdm_status_t status);

/*
 * @brief API to assign voice calls and messages to SIM1, SIM2 or to deassign voice calls and sms.
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * This function can be called to change or clear actual assignment of voice calls and messages.
 *  - If SIM slot ID passed as argument is not an empty string it represents preferred assignment: SIM1 or SIM2.
 *  - If NULL argument is passed it clears the current assignment, which corresponds to the ALWAYS ASK option in Tizen.
 *  - If argument does not stand for a valid device name - #MDM_RESULT_INVALID_PARAM error is returned.
 *  - If restrictions introduced by #mdm_msim_allow_user_assign_voice_calls_and_messages_to_sim are active admin is
 still able to change the assignment.
 *  - If the assignment to first slot is done by admin with this function and then the service goes down, 3 use cases
 can be considered:
 *    1. If user assigns voice calls/messages to the second slot that was previously restricted by admin, the second
 assignment is valid until service is restarted.
 *       After the service starts again the assignment value is reset to the last value estabilished by
 #mdm_msim_set_assign_voice_calls_and_messages_to_sim.
 *    2. If user assigns voice calls/messages to the second slot that was previously allowed by admin, the second
 assignment remains valid even after service restart.
 *    3. If user clears the assignment to ALWAYS ASK option, it remains valid after service restart, no matter if the
 assignment to SIM1 and SIM2 slot was restricted or not.
 *  - If voice calls and messages are unassigned (ALWAYS ASK option is active) any client can assign SIM slot ID to
 capture voice calls and messages.
 *  - If voice calls and messages are assigned to SIM1 or SIM2, only the same admin is authorized to change this
 assignment.
 *  - If the assignment estabilished by one admin is attempted to be changed by the other admin - #MDM_NOT_AN_OWNER
 value is returned.
 *  - If the admin that assigned voice calls and messages to SIM ID is removed the Tizen's assignment is cleared.
 *  - If one admin set a new assignment to e.g. SIM1 slot and the second admin tries to change this to SIM2
 (#MDM_NOT_AN_OWNER is returned),
 *    then if the first one is deregistered - Tizen's assignment is cleared and the second assignment is ignored.
 *    Finally, the system voice calls and messages are unassigned in this case.
 *
 * @code{.c}
 *
        mdm_result_t ret = mdm_msim_set_assign_voice_calls_and_messages_to_sim("SIM1");

        if (ret == MDM_RESULT_SUCCESS) {
            // voice assignment succeeded
         } else {
            // function error
        }
 *
 * @endcode
 *
 * @param[in] id  SIM slot id.
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful call.
 * @retval #MDM_RESULT_FAIL General failure.
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported.
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter.
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 * @retval #MDM_NOT_AN_OWNER Current client is not allowed to change a value estabilished by other admin.
 *
 * @see mdm_msim_allow_user_assign_voice_calls_and_messages_to_sim
 * @see mdm_msim_get_assign_voice_calls_and_messages_to_sim
 *
 */
mdm_result_t mdm_msim_set_assign_voice_calls_and_messages_to_sim(const char *id);

/*
 * @brief API to get current assignment of voice calls and messages.
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * This function can be called to get the actual subscription of voice calls and messages from the system.
 * If (mdm_data_t *)->data contains "SIM1" string it indicates that SIM1 slot is assigned to capture voice calls and
 messages.
 * If (mdm_data_t *)->data contains "SIM2" string it indicates that SIM2 slot is assigned to capture voice calls and
 messages.
 * If (mdm_data_t *)->data points to NULL it indicates that no SIM slot is assigned to capture voice calls and messages
 which
 * corresponds to ALWAYS ASK option in SIM card manager.
 *
 * @code{.c}
 *
    mdm_data_t *res = mdm_msim_get_assign_voice_calls_and_messages_to_sim();

    if (res->ret == MDM_RESULT_SUCCESS) {
        // call succeeded

        if (g_strcmp0((const char*)res->data, NULL) == 0) {
            // no SIM slot is assigned for voice calls
        } else {
            if (g_strcmp0((const char*)res->data, "SIM1") == 0) {
                // SIM1 slot is assigned for voice calls
            } else {
                if (g_strcmp0((const char*)res->data, "SIM2") == 0) {
                    // SIM2 slot is assigned for voice calls
                } else {
                    // unknown voice calls assignment
                }
            }
        }
    } else {
        // error occured
    }
 *
 * @endcode
 *
 * @return (mdm_data_t *)->data contains "SIM1", "SIM2" or points to NULL.
 * @return (mdm_data_t *)->ret is one of the below result codes:
 *
 * @retval #MDM_RESULT_SUCCESS Successful call.
 * @retval #MDM_RESULT_FAIL General failure.
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported.
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter.
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @see mdm_msim_set_assign_voice_calls_and_messages_to_sim
 *
 */
mdm_data_t *mdm_msim_get_assign_voice_calls_and_messages_to_sim(void);

/*
 * @brief API to assign data calls to SIM1 or SIM2.
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * This function can be invoked to change the actual assignment of data calls.
 * If SIM ID passed as an argument is not an empty string it represents a preferred data assignment: SIM1 or SIM2.
 * If it doesn't stand for a valid device name - MDM_RESULT_INVALID_PARAM error is returned.
 * If SIM ID points to NULL - MDM_RESULT_INVALID_PARAM error is returned as well.
 * Setting data assignment can be performed when it's not restricted by mdm_msim_allow_user_assign_data_calls_to_sim.
 * If data calls are unassigned any client can assign SIM ID to capture data calls.
 * If data calls are assigned to SIM1 or SIM2, only the same admin is authorized to change this assignment.
 * If the current assignment is attempted to be changed by the other admin - MDM_NOT_AN_OWNER error is returned.
 * If the admin that assigned data calls to SIM ID is removed the Tizen's assignment is not cleared.
 * E.g. if one client set a new assignment to SIM1 and the second client tried to change this to SIM2 -
 * MDM_NOT_AN_OWNER is returned. Then, if the first one is deregistered - Tizen's assignment remains the same
 * and the second assignment is ignored. In this case, the data calls in system are assigned to SIM1, but
 * data calls become free to be assigned by the second admin (MDM_NOT_AN_OWNER will not be returned).
 *
 * @code{.c}
 *
    mdm_result_t ret = mdm_msim_set_assign_data_calls_to_sim("SIM1");

    if (ret == MDM_RESULT_SUCCESS) {
        // data assignment succeeded
    } else {
        // function error
    }
 *
 * @endcode
 *
 * @param[in]   id   SIM id.
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error *
 * @retval #MDM_RESULT_SUCCESS Successful call.
 * @retval #MDM_RESULT_FAIL General failure.
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported.
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter.
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 * @retval #MDM_NOT_AN_OWNER Current client is not allowed to change a value estabilished by other client.
 *
 * @see mdm_msim_is_user_allowed_assign_data_calls_to_sim
 * @see mdm_msim_get_assign_data_calls_to_sim
 *
 */
mdm_result_t mdm_msim_set_assign_data_calls_to_sim(const char *id);

/*
 * @brief API to get current data calls assignment.
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * This function can be called to get the actual subscription of data calls.
 * If (mdm_data_t *)->data contains "SIM1" string it indicates that SIM1 ID is assigned to capture data calls.
 * If (mdm_data_t *)->data contains "SIM2" string it indicates that SIM2 ID is assigned to capture data calls.
 * If (mdm_data_t *)->data points to NULL it indicates that no SIM card is assigned to capture data calls.
 *
 * @code{.c}
 *
    mdm_data_t *res = mdm_msim_get_assign_data_calls_to_sim();

    if (res->ret == MDM_RESULT_SUCCESS) {
        // call succeeded

        if (g_strcmp0((const char*)res->data, NULL) == 0) {
            // no SIM card is assigned for data calls
        } else {
            if (g_strcmp0((const char*)res->data, "SIM1") == 0) {
                // SIM1 is assigned for data calls
            } else {
                if (g_strcmp0((const char*)res->data, "SIM2") == 0) {
                    // SIM2 is assigned for data calls
                } else {
                    // unknown data calls assignment
                }
            }
        }
    } else {
        // error occured
    }
 *
 * @endcode
 *
 * @return (mdm_data_t *)->data contains "SIM1", "SIM2" or points to NULL.
 * @return (mdm_data_t *)->ret is one of the below result codes:
 *
 * @retval #MDM_RESULT_SUCCESS Successful call.
 * @retval #MDM_RESULT_FAIL General failure.
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported.
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter.
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @see mdm_msim_set_assign_data_calls_to_sim
 *
 */
mdm_data_t *mdm_msim_get_assign_data_calls_to_sim(void);

/*
 * @brief API to allow/restrict user possibility to change data call assignment to specified sim card.
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * This function can be called to enable/disable possibility to change data call assignment to specified sim card.
 * When restricted, user is disallowed to change data call assignment to the specified sim card.
 *
 * @code{.c}

    mdm_result_t ret = mdm_msim_allow_user_assign_data_calls_to_sim("SIM1", MDM_RESTRICTED);

    if (ret != MDM_RESULT_SUCCESS) {
        // user is disallowed to set voice call assignment to the specified sim card
    } else {
        // function error
    }
 *
 * @endcode
 *
 * @param[in]       id      SIM id.
 * @param[in]       allow
 *                      #MDM_ALLOWED      = 0,
 *                      #MDM_RESTRICTED   = 1,
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @see mdm_msim_is_user_allowed_assign_data_calls_to_sim
 *
 */
mdm_result_t mdm_msim_allow_user_assign_data_calls_to_sim(const char *id, mdm_status_t allow);

/*
 * @brief API to check whether user has possibility to change voice call/sms assignment.
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * This function can be called to check for possibility to change voice call and messages assignment to specified sim
 slot.
 * When restricted, user is disallowed to change voice call/sms assignment to the specified sim slot.
 *
 * @code{.c}
    mdm_status_t ret = mdm_msim_is_user_allowed_assign_voice_calls_and_messages_to_sim("SIM1");

    if (ret == MDM_ALLOWED) {
        // user is allowed to set voice call/sms assignment
    } else {
        if (ret == MDM_RESTRICTED) {
            // user is not allowed to set voice call/sms assignment
        } else {
            // error occured
        }
    }
 *
 * @endcode
 *
 * @param[in]   id   SIM slot ID
 *
 * @return #mdm_status_t : Current mode of operation, one of #MDM_ALLOWED, #MDM_RESTRICTED or #MDM_STATUS_ERROR.
 *
 * @see mdm_msim_allow_user_assign_voice_calls_and_messages_to_sim
 *
 */
mdm_status_t mdm_msim_is_user_allowed_assign_voice_calls_and_messages_to_sim(const char *id);

/*
 * @brief API to check whether user have possibility to change data call assignment to specified sim card.
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * This function can be called to check for possibility to change data call assignment to specified sim card.
 * When restricted, user is disallowed to change voice call assignment to the specified sim card.
 *
 * @code{.c}
    mdm_status_t ret = mdm_msim_is_user_allowed_assign_data_calls_to_sim("SIM1");

    if (ret == MDM_ALLOWED) {
        // user is allowed to set voice call assignment to the specified sim card
    } else {
        // user is not allowed (or error, check for MDM_STATUS_ERROR).
    }
 *
 * @endcode
 *
 * @param[in]       id      SIM id.
 *
 * @return #mdm_status_t : Current mode of operation, one of #MDM_ALLOWED or #MDM_RESTRICTED (or MDM_STATUS_ERROR).
 *
 * @see mdm_msim_allow_user_assign_data_calls_to_sim
 *
 */
mdm_status_t mdm_msim_is_user_allowed_assign_data_calls_to_sim(const char *id);

/*
 * @brief Function to check if given SIM card is allowed.
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Admin can check if given SIM card is allowed or restricted. If a SIM card is
 * restricted, user can't use the SIM card (e.g. for calls, messaging or data
 * transfer).
 * By default all SIM cards are allowed.
 *
 * @code{.c}
    mdm_status_t ret = mdm_msim_get_allow_sim();
    if (ret != MDM_STATUS_ERROR) {
        if (ret == MDM_ALLOWED) {
            // SIM card allowed.

        } else {
            // SIM card restricted.
        }
    } else {
        // Function error.
    }
 * @endcode
 *
 * @param[in] id SIM card id. Check #mdm_msim_get_sim_ids() for available SIM card ids.
 *
 * @return #mdm_status_t : #MDM_ALLOWED if user is allowed to use given SIM card, #MDM_RESTRICTED otherwise.
 *         On error functions returns #MDM_STATUS_ERROR, function will fail on incorrect SIM card id.
 *
 * @see mdm_msim_set_allow_sim
 */
mdm_status_t mdm_msim_get_allow_sim(const char *id);

/*
 * @brief Function to allow or restrict given SIM card.
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Admin can restrict or allow given SIM card. If a SIM card is restricted, user
 * can't use the SIM card (e.g. for calls, messaging or data transfer).
 * By default all SIM cards are allowed.
 *
 * @code{.c}
    mdm_result_t ret = mdm_msim_set_allow_sim("SIM1", MDM_RESTRICTED);
    if (ret != MDM_RESULT_SUCCESS) {
        // Operation failed.

    } else {
        // Usage of SIM card is restricted.
    }
 * @endcode
 *
 * @param[in] id    SIM card id. Check mdm_msim_get_sim_ids() for available SIM card ids.
 * @param[in] allow Either #MDM_ALLOWED to allow SIM card or #MDM_RESTRICTED to restrict it.
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @see mdm_msim_get_allow_sim
 */
mdm_result_t mdm_msim_set_allow_sim(const char *id, mdm_status_t allow);

/* For dual sim end */

/*
 * @brief API function to change a PIN code for the current SIM card.
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * This function changes SIM PIN code (if possible) for the current SIM card.
 * It uses asynchronous Tizen's function to send a DBUS request to telephony server.
 * Current PIN code must be correctly typed, otherwise MDM_RESULT_FAIL is returned.
 * If SIM card is not inserted MDM_RESULT_FAIL is returned.
 * If a new PIN code is not valid MDM_RESULT_FAIL is returned.
 *
 * @code{.c}
 *
    mdm_result_t ret = mdm_change_sim_pin_code("0000", "6666");
    if (ret != MDM_RESULT_SUCCESS) {
        // changing password failed
    } else {
        // PIN changed successfully
    }
 *
 * @endcode
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.phonerestriction
 *
 * @param[in] current_pin_code Current PIN code.
 * @param[in] new_pin_code PIN code to be set.
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @par Permission:
 * Usage of this API is restricted to registered clients only.
 *
 */
mdm_result_t mdm_change_sim_pin_code(const char *current_pin_code, const char *new_pin_code);

/*
 * @brief API function to enable a PIN code locking for the current SIM card.
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * API to enable SIM card's PIN lock. The user is prevented from using the SIM card in other devices,
 * since a PIN code is required to use the SIM. It uses PH-SIM (phone-SIM) facility type and locks phone
 * to SIM/UICC card. MT asks for the password when a SIM/UICC card other than current SIM/UICC cardis inserted.
 * MT may remember a certain amount of previously used cards, thus not requiring the password,
 * when they are inserted. If SIM card is not inserted MDM_RESULT_FAIL is returned.
 * An administrator can use this API to enable the SIM card's PIN lock. The lock is transparent to the user:
 * whenever the device is powered on, it automatically unlocks the SIM card for that session. However, if
 * the SIM card is moved to another device, it remains locked.
 *
 * @remark
 * PIN lock restriction #mdm_status_t is written to #MDM_POLICY_ON_SIM_PIN_LOCK notification file.
 * You can register a callback for this event using #mdm_register_policy_receiver.
 *
 * @code{.c}
 *
    mdm_result_t ret = mdm_enable_sim_pin_lock("0000");
    if (ret != MDM_RESULT_SUCCESS) {
        // failed
    } else {
        // succeeded
    }
 *
 * @endcode
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.phonerestriction
 *
 * @param[in] pin_code current SIM card's PIN code
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @par Permission:
 * Usage of this API is restricted to registered clients only.
 *
 * @see mdm_disable_sim_pin_lock
 * @see mdm_is_sim_pin_lock_enabled
 */
mdm_result_t mdm_enable_sim_pin_lock(const char *pin_code);

/*
 * @brief API function to disable a PIN code locking for the current SIM card.
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * API to disable SIM card's PIN lock. User is able to use SIM card on other devices and no PIN codeis required.
 * This function disables the PH-SIM (phone-SIM) facility. If SIM card is not inserted MDM_RESULT_FAIL is returned.
 * To disable the SIM PIN lock, the administrator must provide the current PIN code,
 * which is a numeric code of 4 to 8 digits.
 *
 * @remark
 * PIN lock restriction #mdm_status_t is written to #MDM_POLICY_ON_SIM_PIN_LOCK notification file.
 * You can register a callback for this event using #mdm_register_policy_receiver.
 *
 * @code{.c}
 *
    mdm_result_t ret = mdm_disable_sim_pin_lock("0000");
    if (ret != MDM_RESULT_SUCCESS) {
        // failed
    } else {
        // succeeded
    }
 *
 * @endcode
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.phonerestriction
 *
 * @param[in] pin_code Current SIM card's PIN code
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @par Permission:
 * Usage of this API is restricted to registered clients only.
 *
 * @see mdm_enable_sim_pin_lock
 * @see mdm_is_sim_pin_lock_enabled
 */
mdm_result_t mdm_disable_sim_pin_lock(const char *pin_code);

/*
 * @brief API function to check if the SIM facility is locked.
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * This API might be used to check if PIN locking was done by mdm_enable_sim_pin_lock or
 * undone by mdm_disable_sim_pin_lock.
 *
 * @code{.c}
 *
    mdm_status_t ret = mdm_is_sim_pin_lock_enabled();
    if (ret == MDM_TRUE) {
        // SIM facility is locked
    } else if (ret == MDM_FALSE) {
        // SIM facility is unlocked
    }
 *
 * @endcode
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.phonerestriction
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @par Permission:
 * Usage of this API is restricted to registered clients only.
 *
 * @see mdm_enable_sim_pin_lock
 * @see mdm_disable_sim_pin_lock
 */
mdm_status_t mdm_is_sim_pin_lock_enabled(void);

/*
 * @brief Function to restrict end users from changing mobile data settings.
 *
 * @since_mdm 2.2.0
 *
 * @since_tizen 3.0.0.1
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Use this API to restrict end users from modifying mobile data settings.
 * \n NOTE — This API call will block changes from any sources.
 *
 * @remark
 * This action is signalized by writing #mdm_status_t to #MDM_POLICY_ON_MOBILE_DATA_CHANGE notification file.
 * You can register a callback for this event using #mdm_register_policy_receiver.
 *
 * @code{.c}
    mdm_result_t result = knox_mdm_set_allow_mobile_data_change("SIM1", MDM_ALLOWED);
    if(result == MDM_RESULT_SUCCESS) {
        // Success
        ...
    } else {
        // Error
        ...
    }
 * @endcode
 * @param[in] status #MDM_RESTRICTED — The end user is restricted from modifying mobile data settings.
 *                   \n #MDM_ALLOWED — The end user is allowed to modify mobile data settings.
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.phonerestriction
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS upon successful configuration of end user permission to change mobile data
 settings, or an
 error code from the values listed below upon failure.
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @see knox_mdm_get_allow_mobile_data_change
 */
mdm_result_t knox_mdm_set_allow_mobile_data_change(const char *sim_id, const mdm_status_t status);

/*
 * @brief Function to check if end users are allowed to make modifications to mobile data settings.
 *
 * @since_mdm 2.2.0
 *
 * @since_tizen 3.0.0.1
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Use this API to check end user permission to make changes to the mobile data settings.
 *
 * @code{.c}
    mdm_status_t status = knox_mdm_get_allow_mobile_data_change("SIM1");
    if(result == MDM_RESTRICTED) {
        // Changes are blocked
        ...
    } else if(result == MDM_ALLOWED) {
        // Changes are allowed
        ...
    }
    else
    {
        // ERROR
        ...
    }
 * @endcode
 *
 * @return #mdm_status_t : The current prevention status.
 * @retval #MDM_ALLOWED Mobile Data is prevented
 * @retval #MDM_RESTRICTED the end user is granted to modify Mobile Data.
 * @retval #MDM_STATUS_ERROR – on any error.
 *
 * @see knox_mdm_set_allow_mobile_data_change
 */
mdm_status_t knox_mdm_get_allow_mobile_data_change(const char *sim_id);

/* --------------------------------------------------------------------------------------------------------
 *                                        HIDDEN DOCUMENTATION
 * --------------------------------------------------------------------------------------------------------
 *
 * Hidden documentation won't be generated by doxygen unless
 * PHONE_RESTRICTION_HIDDEN_API section is added to the ENABLED_SECTIONS
 * in the Doxygen configuration file.
 */

/*
 * @brief API to get the limit of incoming calls for day, week or month
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * This method returns the restricted limit of number of incoming calls based on the parameter passed to it
 *
 * @code{.c}
        int value = 0;
    mdm_result_t ret = mdm_msim_get_limit_of_incoming_calls("SIM1", MDM_LIMIT_NUMBER_OF_CALLS_BY_DAY, &value);
    if (ret == MDM_RESULT_SUCCESS) {
        printf("%d", value);
    }
 *
 * @endcode
 *
 * @param[in]       id      id of sim limit is applied
 * @param[in]       type    Must be one of the these values
 *                          #MDM_LIMIT_NUMBER_OF_CALLS_BY_DAY,
 *                          #MDM_LIMIT_NUMBER_OF_CALLS_BY_WEEK,
 *                          #MDM_LIMIT_NUMBER_OF_CALLS_BY_MONTH
 * @param[in]       p_value Get information of call
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @see mdm_msim_set_limit_of_incoming_calls
 *
 */
mdm_result_t mdm_msim_get_limit_of_incoming_calls(const char *id, mdm_call_limit_t type, unsigned int *p_value);

/*
 * @brief API to get the limit of incoming SMSs for day, week or month
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * This method returns the restricted limit of number of incoming SMSs based on the parameter passed to it
 *
 * @code{.c}
        int value = 0;
    mdm_result_t ret = mdm_msim_get_limit_of_incoming_sms("SIM1", MDM_LIMIT_NUMBER_OF_SMS_BY_DAY, &value);
    if (ret == MDM_RESULT_SUCCESS) {
        printf("%d", value);
    }
 *
 * @endcode
 *
 * @param[in]   id      id of sim limit is applied
 * @param[in]   type    Must be one of the these values
 *                      #MDM_LIMIT_NUMBER_OF_SMS_BY_DAY,
 *                      #MDM_LIMIT_NUMBER_OF_SMS_BY_WEEK,
 *                      #MDM_LIMIT_NUMBER_OF_SMS_BY_MONTH
 * @param[in]   p_value Get information of sms
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @see mdm_msim_set_limit_of_incoming_sms
 *
 */
mdm_result_t mdm_msim_get_limit_of_incoming_sms(const char *id, mdm_sms_limit_t type, unsigned int *p_value);

/*
 * @brief API to get the limit of outgoing calls for day, week or month
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * This method returns the restricted limit of number of outgoing calls based on the parameter passed to it
 *
 * @code{.c}
        int value = 0;
    mdm_result_t ret = mdm_msim_get_limit_of_outgoing_calls("SIM1", MDM_LIMIT_NUMBER_OF_CALLS_BY_DAY, &value);
    if (ret == MDM_RESULT_SUCCESS) {
        printf("%d", value);
    }
 *
 * @endcode
 *
 * @param[in]       id      Id of sim limit is applied
 * @param[in]       type    Must be one of the these values
 *                          #MDM_LIMIT_NUMBER_OF_CALLS_BY_DAY,
 *                          #MDM_LIMIT_NUMBER_OF_CALLS_BY_WEEK,
 *                          #MDM_LIMIT_NUMBER_OF_CALLS_BY_MONTH
 * @param[in]       p_value Get information of call
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @see mdm_msim_set_limit_of_outgoing_calls
 *
 */
mdm_result_t mdm_msim_get_limit_of_outgoing_calls(const char *id, mdm_call_limit_t type, unsigned int *p_value);

/*
 * @brief API to get the limit of outgoing SMSs for day, week or month
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * This method returns the restricted limit of number of outgoing SMSs based on the parameter passed to it
 *
 * @code{.c}
        int value = 0;
    mdm_result_t ret = mdm_msim_get_limit_of_outgoing_sms("SIM1", MDM_LIMIT_NUMBER_OF_SMS_BY_DAY, &value);
    if (ret == MDM_RESULT_SUCCESS) {
        printf("%d", value);
    }
 *
 * @endcode
 *
 * @param[in]       id      Id of sim limit is applied
 * @param[in]       type    Must be one of the these values
 *                          #MDM_LIMIT_NUMBER_OF_SMS_BY_DAY,
 *                          #MDM_LIMIT_NUMBER_OF_SMS_BY_WEEK,
 *                          #MDM_LIMIT_NUMBER_OF_SMS_BY_MONTH
 * @param[in]       p_value Get information of sms
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @see mdm_msim_set_limit_of_outgoing_sms
 *
 */
mdm_result_t mdm_msim_get_limit_of_outgoing_sms(const char *id, mdm_sms_limit_t type, unsigned int *p_value);

/*
 * @brief API to set the limit of number of incoming calls per day, week and month
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Admin can set a limit to the number of incoming calls by day, week or month. Passing "0" as a parameter means that
 there is no limit on the number of calls to what it is related (day, week or month).
 *
 * @code{.c}
    // Set the incoming call limit to 5 by day, no limit by week, 100 by month
    mdm_result_t ret = mdm_msim_set_limit_of_incoming_calls("SIM1", 5, 0, 100);
    if (ret != MDM_RESULT_SUCCESS) {
        // failed setting count
    } else {
        // success setting count
    }
 *
 * @endcode
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.phonerestriction
 *
 * @param[in]       id              Id of sim limit is applied
 * @param[in]       limitbyday      The maximum number of bytes for a day.
 * @param[in]       limitbyweek     The maximum number of bytes for a week.
 * @param[in]       limitbymonth    The maximum number of bytes for a month.
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @par Permission:
 * Usage of this API is restricted to registered clients only.
 *
 * @see mdm_msim_get_limit_of_incoming_calls
 *
 */
mdm_result_t mdm_msim_set_limit_of_incoming_calls(const char *id, unsigned int limitbyday, unsigned int limitbyweek,
                                                  unsigned int limitbymonth);

/*
 * @brief API to set the limit of number of incoming SMSs per day, week and month
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Admin can set a limit to the number of incoming SMSs by day, week or month. Passing "0" as a parameter means that
 there is no limit on the number of SMSs to what it is related (day, week or month).
 *
 * @code{.c}
    // Set the incoming sms limit to 5 by day, no limit by week, 100 by month
    mdm_result_t ret = mdm_msim_set_limit_of_incoming_sms("SIM1", 5, 0, 100);
    if (ret != MDM_RESULT_SUCCESS) {
        // failed setting count
    } else {
        // success setting count
    }
 *
 * @endcode
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.phonerestriction
 *
 * @param[in]       id              Id of sim limit is applied
 * @param[in]       limitbyday      The maximum number of bytes for a day.
 * @param[in]       limitbyweek     The maximum number of bytes for a week.
 * @param[in]       limitbymonth    The maximum number of bytes for a month.
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @par Permission:
 * Usage of this API is restricted to registered clients only.
 *
 * @see mdm_msim_get_limit_of_incoming_sms
 *
 */
mdm_result_t mdm_msim_set_limit_of_incoming_sms(const char *id, unsigned int limitbyday, unsigned int limitbyweek,
                                                unsigned int limitbymonth);

/*
 * @brief API to set the limit of number of outgoing calls per day, week and month
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Admin can set a limit to the number of outgoing calls by day, week or month. Passing "0" as a parameter means that
 there is no limit on the number of calls to what it is related (day, week or month).
 *
 * @code{.c}
    // Set the outgoing calls limit to 5 by day, no limit by week, 100 by month
    mdm_result_t ret = mdm_msim_set_limit_of_outgoing_calls2("SIM1", 5, 0, 100);
    if (ret != MDM_RESULT_SUCCESS) {
        // failed setting count
    } else {
        // success setting count
    }
 *
 * @endcode
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.phonerestriction
 *
 * @param[in]       id              Id of sim limit is applied
 * @param[in]       limitbyday      The maximum number of bytes for a day.
 * @param[in]       limitbyweek     The maximum number of bytes for a week.
 * @param[in]       limitbymonth    The maximum number of bytes for a month.
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @par Permission:
 * Usage of this API is restricted to registered clients only.
 *
 * @see mdm_msim_get_limit_of_outgoing_calls
 *
 */
mdm_result_t mdm_msim_set_limit_of_outgoing_calls(const char *id, unsigned int limitbyday, unsigned int limitbyweek,
                                                  unsigned int limitbymonth);

/*
 * @brief API to set the limit of number of outgoing SMSs per day, week and month
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Admin can set a limit to the number of outgoing SMSs by day, week or month. Passing "0" as a parameter means that
 there is no limit on the number of SMSs to what it is related (day, week or month).
 *
 * @code{.c}
    // Set the outgoing SMS limit to 5 by day, no limit by week, 100 by month
    mdm_result_t ret = mdm_msim_set_limit_of_outgoing_sms("SIM1", 5, 0, 100);
    if (ret != MDM_RESULT_SUCCESS) {
        // failed setting count
    } else {
        // success setting count
    }
 *
 * @endcode
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.phonerestriction
 *
 * @param[in]       id              Id of sim limit is applied
 * @param[in]       limitbyday      The maximum number of bytes for a day.
 * @param[in]       limitbyweek     The maximum number of bytes for a week.
 * @param[in]       limitbymonth    The maximum number of bytes for a month.
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @par Permission:
 * Usage of this API is restricted to registered clients only.
 *
 * @see mdm_msim_get_limit_of_outgoing_sms
 *
 */
mdm_result_t mdm_msim_set_limit_of_outgoing_sms(const char *id, unsigned int limitbyday, unsigned int limitbyweek,
                                                unsigned int limitbymonth);

/*
 * @brief API to check whether data carrier network usage limit is enabled or not per SIM.
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Applications, services and admin client can use this interface to verify if data call limiting policy is enabled on
 * the device.
 * @note If the limit of data has been enabled by admin client no other application shall allow alerting this limit.
 *
 * @code{.c}
 *
 * // Sample code that demonstrates how setting application can decide whether enable or disable data call limit
 * // submenu.
 * mdm_status_t ret = mdm_msim_get_data_call_limit_enabled(id, n_all_admin);
 * if (ret != MDM_STATUS_ERROR) {
 *     if (ret == MDM_ENABLED) {
 *         // Admin client controls data call limits. Disable the data call limit submenu.
 *         _set_enabled(submenu_data_call_limit, FALSE);
 *
 *     } else {
 *         // Admin client doesn't control data call limits - control is left for user. Enable the data call limit
 * submenu.
 *         _set_enabled(submenu_data_call_limit, TRUE);
 *     }
 * } else {
 *     // function error
 * }
 *
 * @endcode
 *
 * @param[in]       id      SIM id.
 *
 * @return #mdm_status_t : Current mode of operation, one of #MDM_ENABLED or #MDM_DISABLED
 *
 * @see mdm_msim_enable_data_call_limit
 * @see mdm_msim_get_limit_of_data_calls
 */
mdm_status_t mdm_msim_get_data_call_limit_enabled(const char *id);

/*
 * @brief API to check if number of calls are limited per SIM.
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Admin can use this method to verify if there is a limitation on the number of calls on device per sim card.
 *
 * @code{.c}
    mdm_status_t ret = mdm_msim_get_limit_number_of_calls_enabled(id, n_all_admin);
    if (ret != MDM_STATUS_ERROR) {
        if (ret == MDM_TRUE) {
            // feature enabled
        } else {
            // feature disabled
        }
    } else {
        // function error
    }
 *
 * @endcode
 *
 * @param[in]       id      SIM id.
 *
 * @return #mdm_status_t : Current mode of operation, one of #MDM_ALLOWED or #MDM_RESTRICTED
 *
 * @see mdm_msim_enable_limit_number_of_calls
 *
 */
mdm_status_t mdm_msim_get_limit_number_of_calls_enabled(const char *id);

/*
 * @brief API to check if number of SMSs are limited per SIM.
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Admin can use this method to verify if there is a limitation on the number of SMSs on device per sim card.
 *
 * @code{.c}
    mdm_status_t ret = mdm_msim_get_limit_number_of_sms_enabled(id, n_all_admin);
    if (ret != MDM_STATUS_ERROR) {
        if (ret == MDM_TRUE) {
            // feature enabled
        } else {
            // feature disabled
        }
    } else {
        // function error
    }
 *
 * @endcode
 *
 * @param[in]       id      SIM id.
 *
 * @return #mdm_status_t : Current mode of operation, one of #MDM_ALLOWED or #MDM_RESTRICTED
 *
 * @see mdm_msim_enable_limit_number_of_sms
 *
 */
mdm_status_t mdm_msim_get_limit_number_of_sms_enabled(const char *id);

/*
 * @brief API to get the limits of sent and received data for mobile carriers per SIM.
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * The API can be used by admin clients to get information about the limit of received and sent data, date the limit was
 * set and the period of time when the limit was set.
 *
 * @note If limit is disabled, the result of this call will fail - check with #mdm_msim_get_data_call_limit_enabled().
 * @note The API returns only limits set by mdm_msim_set_limit_of_data_calls(). It doesn't return how many bytes left.
 *
 * @code{.c}
 *
 * // Sample code that demonstrates how setting application can decide whether enable or disable data call limit
 * // submenu.
 *
 * mdm_status_t ret = mdm_msim_get_data_call_limit_enabled(id, n_all_admin);
 * if (ret == MDM_ENABLED) {
 *     // Admin client controls data call limits.
 *
 *     time_t date_set, period;
 *     time_t send_limit, recv_limit;
 *
 *     mdm_result_t ret = mdm_msim_get_limit_of_data_calls(id, n_all_admin, &date_set, &period, &send_limit,
 * &recv_limit);
 *     if (ret == MDM_RESULT_SUCCESS) {
 *         // Call successful, continue.
 *
 *     } else {
 *         // Call failed.
 *     }
 *
 * } else {
 *    // Policy is either disabled or we've got an error - check.
 * }
 *
 * @endcode
 *
 * @param[in]       id              SIM card id. Check mdm_msim_get_sim_ids() for available SIM card ids.
 * @param[in,out]   p_date_set      Date when limit has been set.
 * @param[in,out]   p_period        Period for which data call limit has been set.
 * @param[in,out]   p_send_limit    Amount of data device can send in given period in megabytes.
 * @param[in,out]   p_recv_limit    Amount of data device can receive in given period in megabytes.
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @see mdm_msim_set_limit_of_data_calls
 * @see mdm_msim_get_data_call_limit_enabled
 *
 */
mdm_result_t mdm_msim_get_limit_of_data_calls(const char *id, time_t *p_date_set, time_t *p_period,
                                              size_t *p_send_limit, size_t *p_recv_limit);

/*
 * @brief API to enable or disable limit of number of calls
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Admin can use this policy to enable or disable the limit of number of calls allowed on the device.
 * This policy is complemented by: #mdm_msim_set_limit_of_incoming_calls() and #mdm_msim_set_limit_of_outgoing_calls().
 *
 * @code{.c}
    mdm_result_t ret = mdm_msim_enable_limit_number_of_calls(id, TRUE);
    if (ret != MDM_RESULT_SUCCESS) {
        // function error
    } else {
        // function success
    }
 *
 * @endcode
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.phonerestriction
 *
 * @param[in]       id      SIM id.
 * @param[in]       status  True to enable limit number of calls, false to disable limit number of calls.
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @par Permission:
 * Usage of this API is restricted to registered clients only.
 *
 * @see mdm_msim_set_limit_of_incoming_calls
 * @see mdm_msim_set_limit_of_outgoing_calls
 */
mdm_result_t mdm_msim_enable_limit_number_of_calls(const char *id, mdm_status_t status);

/*
 * @brief API to enable or disable limit of number of SMSs
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Admin can use this policy to enable or disable the limit of number of calls allowed on the device.
 * This policy is complemented by: #mdm_msim_set_limit_of_incoming_sms and #mdm_msim_set_limit_of_outgoing_sms.
 *
 * @code{.c}
    mdm_result_t ret = mdm_msim_enable_limit_number_of_sms(id, TRUE);
    if (ret != MDM_RESULT_SUCCESS) {
        // function error
    } else {
        // function success
    }
 *
 * @endcode
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.phonerestriction
 *
 * @param[in]       id      SIM id.
 * @param[in]       status  True to enable limit number of SMSs, false to disable limit number of SMSs.
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @par Permission:
 * Usage of this API is restricted to registered clients only.
 *
 * @see mdm_msim_set_limit_of_incoming_sms, mdm_msim_set_limit_of_outgoing_sms
 *
 */
mdm_result_t mdm_msim_enable_limit_number_of_sms(const char *id, mdm_status_t status);

/*
 * @brief API to enable limit of data packet on the device
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Using this API admin client can enable the limit on data packet traffic. The default value for this policy is
 * MDM_DISABLED (it is disabled by default).
 *
 * @remark
 * Restriction #mdm_status_t is written to #MDM_POLICY_ON_DATA_LIMIT notification file.
 * You can register a callback for this event using #mdm_register_policy_receiver.
 *
 * @note To enforce a limit one must call #mdm_set_limit_of_data_calls().
 *
 * @code{.c}
 *
 * mdm_result_t ret = mdm_msim_enable_data_call_limit(id, MDM_ENABLED);
 * if (ret != MDM_RESULT_SUCCESS) {
 *     // Handle error.
 *
 * } else {
 *     // Limit enabled. Now enforce specific limit: for a week we set 100 MB of sent and received data.
 *     time_t WEEK = (time_t)7*24*60*60
 *     ret = mdm_msim_set_limit_of_data_calls(WEEK, 100, 100);
 *     if (ret != MDM_RESULT_SUCCESS) {
 *         // Handle error
 *     }
 * }
 *
 * @endcode
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.phonerestriction
 *
 * @param[in]       id      SIM id.
 * @param[in]       status  #MDM_ENABLED if the device shall limit the data call statistics (count amount of data) No
 *                          limit will be set unless #mdm_set_limit_of_data_calls() is called after this function. When
 *                          #MDM_DISABLED is passed, all limits set are removed.
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @par Permission:
 * Usage of this API is restricted to registered clients only.
 *
 * @see mdm_msim_set_limit_of_data_calls
 * @see mdm_msim_get_data_call_limit_enabled
 *
 */
mdm_result_t mdm_msim_enable_data_call_limit(const char *id, mdm_status_t status);

/*
 * @brief API to set the limit of data packet for given period.
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Admin client can use this interface to limit the amount of data sent and received through carriers network for given
 * period of time. Counting of the time period starts at the moment of calling this function.
 *
 * @remark
 * Set limit is signalized by #MDM_POLICY_ON_DATA_LIMIT notification.
 * You can register a callback for this event using #mdm_register_policy_receiver.
 *
 * @note - Before calling this function, data call limit has to be enbled with #mdm_enable_data_call_limit(). Otherwise
 *       this function will fail and no limit will be enforced.
 * - The total limit size set by this API is a combination of the #sent_limit and #recv_limit.
 * - It is only possible to set limits for daily, weekly and monthly periods in seconds.
 * - Passing #period with different values than the specified before follows the rule below:
 *   Daily period will be set if period >= 0 or period <= 86400.
 *   Weekly period will be set if period > 86400 or period <= 604800.
 *   Montly period will be set if period > 604800.
 *
 * @code{.c}

 * mdm_result_t ret = mdm_msim_enable_data_call_limit(id, MDM_ENABLED);
 * if (ret != MDM_RESULT_SUCCESS) {
 *     // Handle error.
 *
 * } else {
 *     // Limit enabled. Now enforce specific limit: for a week we set 100 MB of sent and received data.
 *     time_t WEEK = (time_t)7*24*60*60
 *     ret = mdm_msim_set_limit_of_data_calls(id, WEEK, 100, 100);
 *     if (ret != MDM_RESULT_SUCCESS) {
 *         // Handle error
 *     }
 * }
 *
 * @endcode
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.phonerestriction
 *
 * @param[in]       id              SIM id.
 * @param[in]       period          Time period in seconds.
 * @param[in]       sent_limit      Limit in megabytes for sent data.
 * @param[in]       recv_limit      Limit in megabytes for received data.
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @par Permission:
 * Usage of this API is restricted to registered clients only.
 *
 * @see mdm_msim_enable_data_call_limit
 * @see mdm_msim_get_data_call_limit_enabled
 * @see mdm_msim_get_limit_of_data_calls
 */
mdm_result_t mdm_msim_set_limit_of_data_calls(const char *id, time_t period, size_t sent_limit, size_t recv_limit);

/*
 * @brief API to reset the counters for incoming and outgoing calls
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * This method resets all the counters for incoming and outgoing calls for each date type (day, week and month). The
 limits set for each kind of call will not be changed.
 *
 * @code{.c}

    mdm_result_t ret = mdm_reset_call_limit_count("SIM1");
    if (ret != MDM_RESULT_SUCCESS) {

    } else {

    }
 *
 * @endcode
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.phonerestriction
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @par Permission:
 * Usage of this API is restricted to registered clients only.
 *
 * @see
 *
 */
extern mdm_result_t mdm_msim_reset_call_limit_count(const char *id);

/*
 * @brief API to reset the counters for incoming and outgoing sms
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.3.2.3
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * This method resets all the counters for incoming and outgoing smses for each date type (day, week and month). The
 limits set for each kind of sms will not be changed.
 *
 * @code{.c}

    mdm_result_t ret = mdm_reset_sms_limit_count("SIM1");
    if (ret != MDM_RESULT_SUCCESS) {

    } else {

        }
 *
 * @endcode
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.phonerestriction
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @par Permission:
 * Usage of this API is restricted to registered clients only.
 *
 * @see
 *
 */
extern mdm_result_t mdm_msim_reset_sms_limit_count(const char *id);

/*
 * @remark
 * Reset counter is signalized by #MDM_POLICY_ON_DATA_LIMIT notification.
 * You can register a callback for this event using #mdm_register_policy_receiver.
 */
extern mdm_result_t mdm_msim_reset_data_call_limit_count(const char *id);


/* -----------------------------------------------------------------------------------------------------------------
 * END OF HIDDEN DOCUMENTATION
 * -----------------------------------------------------------------------------------------------------------------
 */

#ifdef __cplusplus
}
#endif

#endif // LIBMDM_MDM_PHONE_RESTRICTION_H