/*
    Generated by sbus code generator

    Copyright (C) 2017 Red Hat

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef _SBUS_SSS_INTERFACE_H_
#define _SBUS_SSS_INTERFACE_H_

#include "sbus/sbus_interface_declarations.h"
#include "sss_iface/sbus_sss_invokers.h"
#include "sss_iface/sbus_sss_symbols.h"
#include "sss_iface/sbus_sss_keygens.h"

/* Interface: org.freedesktop.FleetCommanderClient */
#define SBUS_IFACE_org_freedesktop_FleetCommanderClient(methods, signals, properties) ({ \
    sbus_interface("org.freedesktop.FleetCommanderClient", NULL, \
        (methods), (signals), (properties)); \
})

/* Method: org.freedesktop.FleetCommanderClient.ProcessSSSDFiles */
#define SBUS_METHOD_SYNC_org_freedesktop_FleetCommanderClient_ProcessSSSDFiles(handler, data) ({ \
    SBUS_CHECK_SYNC((handler), (data), uint32_t, const char *, uint16_t); \
    sbus_method_sync("ProcessSSSDFiles", \
        &_sbus_sss_args_org_freedesktop_FleetCommanderClient_ProcessSSSDFiles, \
        NULL, \
        _sbus_sss_invoke_in_usq_out__send, \
        NULL, \
        (handler), (data)); \
})

#define SBUS_METHOD_ASYNC_org_freedesktop_FleetCommanderClient_ProcessSSSDFiles(handler_send, handler_recv, data) ({ \
    SBUS_CHECK_SEND((handler_send), (data), uint32_t, const char *, uint16_t); \
    SBUS_CHECK_RECV((handler_recv)); \
    sbus_method_async("ProcessSSSDFiles", \
        &_sbus_sss_args_org_freedesktop_FleetCommanderClient_ProcessSSSDFiles, \
        NULL, \
        _sbus_sss_invoke_in_usq_out__send, \
        NULL, \
        (handler_send), (handler_recv), (data)); \
})

/* Interface: org.freedesktop.systemd1.Manager */
#define SBUS_IFACE_org_freedesktop_systemd1_Manager(methods, signals, properties) ({ \
    sbus_interface("org.freedesktop.systemd1.Manager", NULL, \
        (methods), (signals), (properties)); \
})

/* Method: org.freedesktop.systemd1.Manager.RestartUnit */
#define SBUS_METHOD_SYNC_org_freedesktop_systemd1_Manager_RestartUnit(handler, data) ({ \
    SBUS_CHECK_SYNC((handler), (data), const char *, const char *, const char **); \
    sbus_method_sync("RestartUnit", \
        &_sbus_sss_args_org_freedesktop_systemd1_Manager_RestartUnit, \
        NULL, \
        _sbus_sss_invoke_in_ss_out_o_send, \
        NULL, \
        (handler), (data)); \
})

#define SBUS_METHOD_ASYNC_org_freedesktop_systemd1_Manager_RestartUnit(handler_send, handler_recv, data) ({ \
    SBUS_CHECK_SEND((handler_send), (data), const char *, const char *); \
    SBUS_CHECK_RECV((handler_recv), const char **); \
    sbus_method_async("RestartUnit", \
        &_sbus_sss_args_org_freedesktop_systemd1_Manager_RestartUnit, \
        NULL, \
        _sbus_sss_invoke_in_ss_out_o_send, \
        NULL, \
        (handler_send), (handler_recv), (data)); \
})

/* Method: org.freedesktop.systemd1.Manager.StartUnit */
#define SBUS_METHOD_SYNC_org_freedesktop_systemd1_Manager_StartUnit(handler, data) ({ \
    SBUS_CHECK_SYNC((handler), (data), const char *, const char *, const char **); \
    sbus_method_sync("StartUnit", \
        &_sbus_sss_args_org_freedesktop_systemd1_Manager_StartUnit, \
        NULL, \
        _sbus_sss_invoke_in_ss_out_o_send, \
        NULL, \
        (handler), (data)); \
})

#define SBUS_METHOD_ASYNC_org_freedesktop_systemd1_Manager_StartUnit(handler_send, handler_recv, data) ({ \
    SBUS_CHECK_SEND((handler_send), (data), const char *, const char *); \
    SBUS_CHECK_RECV((handler_recv), const char **); \
    sbus_method_async("StartUnit", \
        &_sbus_sss_args_org_freedesktop_systemd1_Manager_StartUnit, \
        NULL, \
        _sbus_sss_invoke_in_ss_out_o_send, \
        NULL, \
        (handler_send), (handler_recv), (data)); \
})

/* Method: org.freedesktop.systemd1.Manager.StopUnit */
#define SBUS_METHOD_SYNC_org_freedesktop_systemd1_Manager_StopUnit(handler, data) ({ \
    SBUS_CHECK_SYNC((handler), (data), const char *, const char *, const char **); \
    sbus_method_sync("StopUnit", \
        &_sbus_sss_args_org_freedesktop_systemd1_Manager_StopUnit, \
        NULL, \
        _sbus_sss_invoke_in_ss_out_o_send, \
        NULL, \
        (handler), (data)); \
})

#define SBUS_METHOD_ASYNC_org_freedesktop_systemd1_Manager_StopUnit(handler_send, handler_recv, data) ({ \
    SBUS_CHECK_SEND((handler_send), (data), const char *, const char *); \
    SBUS_CHECK_RECV((handler_recv), const char **); \
    sbus_method_async("StopUnit", \
        &_sbus_sss_args_org_freedesktop_systemd1_Manager_StopUnit, \
        NULL, \
        _sbus_sss_invoke_in_ss_out_o_send, \
        NULL, \
        (handler_send), (handler_recv), (data)); \
})

/* Interface: sssd.DataProvider.AccessControl */
#define SBUS_IFACE_sssd_DataProvider_AccessControl(methods, signals, properties) ({ \
    sbus_interface("sssd.DataProvider.AccessControl", NULL, \
        (methods), (signals), (properties)); \
})

/* Method: sssd.DataProvider.AccessControl.RefreshRules */
#define SBUS_METHOD_SYNC_sssd_DataProvider_AccessControl_RefreshRules(handler, data) ({ \
    SBUS_CHECK_SYNC((handler), (data)); \
    sbus_method_sync("RefreshRules", \
        &_sbus_sss_args_sssd_DataProvider_AccessControl_RefreshRules, \
        NULL, \
        _sbus_sss_invoke_in__out__send, \
        _sbus_sss_key_, \
        (handler), (data)); \
})

#define SBUS_METHOD_ASYNC_sssd_DataProvider_AccessControl_RefreshRules(handler_send, handler_recv, data) ({ \
    SBUS_CHECK_SEND((handler_send), (data)); \
    SBUS_CHECK_RECV((handler_recv)); \
    sbus_method_async("RefreshRules", \
        &_sbus_sss_args_sssd_DataProvider_AccessControl_RefreshRules, \
        NULL, \
        _sbus_sss_invoke_in__out__send, \
        _sbus_sss_key_, \
        (handler_send), (handler_recv), (data)); \
})

/* Interface: sssd.DataProvider.Autofs */
#define SBUS_IFACE_sssd_DataProvider_Autofs(methods, signals, properties) ({ \
    sbus_interface("sssd.DataProvider.Autofs", NULL, \
        (methods), (signals), (properties)); \
})

/* Method: sssd.DataProvider.Autofs.Enumerate */
#define SBUS_METHOD_SYNC_sssd_DataProvider_Autofs_Enumerate(handler, data) ({ \
    SBUS_CHECK_SYNC((handler), (data), uint32_t, const char *, uint32_t); \
    sbus_method_sync("Enumerate", \
        &_sbus_sss_args_sssd_DataProvider_Autofs_Enumerate, \
        NULL, \
        _sbus_sss_invoke_in_usu_out__send, \
        _sbus_sss_key_usu_0_1, \
        (handler), (data)); \
})

#define SBUS_METHOD_ASYNC_sssd_DataProvider_Autofs_Enumerate(handler_send, handler_recv, data) ({ \
    SBUS_CHECK_SEND((handler_send), (data), uint32_t, const char *, uint32_t); \
    SBUS_CHECK_RECV((handler_recv)); \
    sbus_method_async("Enumerate", \
        &_sbus_sss_args_sssd_DataProvider_Autofs_Enumerate, \
        NULL, \
        _sbus_sss_invoke_in_usu_out__send, \
        _sbus_sss_key_usu_0_1, \
        (handler_send), (handler_recv), (data)); \
})

/* Method: sssd.DataProvider.Autofs.GetEntry */
#define SBUS_METHOD_SYNC_sssd_DataProvider_Autofs_GetEntry(handler, data) ({ \
    SBUS_CHECK_SYNC((handler), (data), uint32_t, const char *, const char *, uint32_t); \
    sbus_method_sync("GetEntry", \
        &_sbus_sss_args_sssd_DataProvider_Autofs_GetEntry, \
        NULL, \
        _sbus_sss_invoke_in_ussu_out__send, \
        _sbus_sss_key_ussu_0_1_2, \
        (handler), (data)); \
})

#define SBUS_METHOD_ASYNC_sssd_DataProvider_Autofs_GetEntry(handler_send, handler_recv, data) ({ \
    SBUS_CHECK_SEND((handler_send), (data), uint32_t, const char *, const char *, uint32_t); \
    SBUS_CHECK_RECV((handler_recv)); \
    sbus_method_async("GetEntry", \
        &_sbus_sss_args_sssd_DataProvider_Autofs_GetEntry, \
        NULL, \
        _sbus_sss_invoke_in_ussu_out__send, \
        _sbus_sss_key_ussu_0_1_2, \
        (handler_send), (handler_recv), (data)); \
})

/* Method: sssd.DataProvider.Autofs.GetMap */
#define SBUS_METHOD_SYNC_sssd_DataProvider_Autofs_GetMap(handler, data) ({ \
    SBUS_CHECK_SYNC((handler), (data), uint32_t, const char *, uint32_t); \
    sbus_method_sync("GetMap", \
        &_sbus_sss_args_sssd_DataProvider_Autofs_GetMap, \
        NULL, \
        _sbus_sss_invoke_in_usu_out__send, \
        _sbus_sss_key_usu_0_1, \
        (handler), (data)); \
})

#define SBUS_METHOD_ASYNC_sssd_DataProvider_Autofs_GetMap(handler_send, handler_recv, data) ({ \
    SBUS_CHECK_SEND((handler_send), (data), uint32_t, const char *, uint32_t); \
    SBUS_CHECK_RECV((handler_recv)); \
    sbus_method_async("GetMap", \
        &_sbus_sss_args_sssd_DataProvider_Autofs_GetMap, \
        NULL, \
        _sbus_sss_invoke_in_usu_out__send, \
        _sbus_sss_key_usu_0_1, \
        (handler_send), (handler_recv), (data)); \
})

/* Interface: sssd.DataProvider.Backend */
#define SBUS_IFACE_sssd_DataProvider_Backend(methods, signals, properties) ({ \
    sbus_interface("sssd.DataProvider.Backend", NULL, \
        (methods), (signals), (properties)); \
})

/* Method: sssd.DataProvider.Backend.IsOnline */
#define SBUS_METHOD_SYNC_sssd_DataProvider_Backend_IsOnline(handler, data) ({ \
    SBUS_CHECK_SYNC((handler), (data), const char *, bool*); \
    sbus_method_sync("IsOnline", \
        &_sbus_sss_args_sssd_DataProvider_Backend_IsOnline, \
        NULL, \
        _sbus_sss_invoke_in_s_out_b_send, \
        _sbus_sss_key_s_0, \
        (handler), (data)); \
})

#define SBUS_METHOD_ASYNC_sssd_DataProvider_Backend_IsOnline(handler_send, handler_recv, data) ({ \
    SBUS_CHECK_SEND((handler_send), (data), const char *); \
    SBUS_CHECK_RECV((handler_recv), bool*); \
    sbus_method_async("IsOnline", \
        &_sbus_sss_args_sssd_DataProvider_Backend_IsOnline, \
        NULL, \
        _sbus_sss_invoke_in_s_out_b_send, \
        _sbus_sss_key_s_0, \
        (handler_send), (handler_recv), (data)); \
})

/* Interface: sssd.DataProvider.Failover */
#define SBUS_IFACE_sssd_DataProvider_Failover(methods, signals, properties) ({ \
    sbus_interface("sssd.DataProvider.Failover", NULL, \
        (methods), (signals), (properties)); \
})

/* Method: sssd.DataProvider.Failover.ActiveServer */
#define SBUS_METHOD_SYNC_sssd_DataProvider_Failover_ActiveServer(handler, data) ({ \
    SBUS_CHECK_SYNC((handler), (data), const char *, const char **); \
    sbus_method_sync("ActiveServer", \
        &_sbus_sss_args_sssd_DataProvider_Failover_ActiveServer, \
        NULL, \
        _sbus_sss_invoke_in_s_out_s_send, \
        _sbus_sss_key_s_0, \
        (handler), (data)); \
})

#define SBUS_METHOD_ASYNC_sssd_DataProvider_Failover_ActiveServer(handler_send, handler_recv, data) ({ \
    SBUS_CHECK_SEND((handler_send), (data), const char *); \
    SBUS_CHECK_RECV((handler_recv), const char **); \
    sbus_method_async("ActiveServer", \
        &_sbus_sss_args_sssd_DataProvider_Failover_ActiveServer, \
        NULL, \
        _sbus_sss_invoke_in_s_out_s_send, \
        _sbus_sss_key_s_0, \
        (handler_send), (handler_recv), (data)); \
})

/* Method: sssd.DataProvider.Failover.ListServers */
#define SBUS_METHOD_SYNC_sssd_DataProvider_Failover_ListServers(handler, data) ({ \
    SBUS_CHECK_SYNC((handler), (data), const char *, const char ***); \
    sbus_method_sync("ListServers", \
        &_sbus_sss_args_sssd_DataProvider_Failover_ListServers, \
        NULL, \
        _sbus_sss_invoke_in_s_out_as_send, \
        _sbus_sss_key_s_0, \
        (handler), (data)); \
})

#define SBUS_METHOD_ASYNC_sssd_DataProvider_Failover_ListServers(handler_send, handler_recv, data) ({ \
    SBUS_CHECK_SEND((handler_send), (data), const char *); \
    SBUS_CHECK_RECV((handler_recv), const char ***); \
    sbus_method_async("ListServers", \
        &_sbus_sss_args_sssd_DataProvider_Failover_ListServers, \
        NULL, \
        _sbus_sss_invoke_in_s_out_as_send, \
        _sbus_sss_key_s_0, \
        (handler_send), (handler_recv), (data)); \
})

/* Method: sssd.DataProvider.Failover.ListServices */
#define SBUS_METHOD_SYNC_sssd_DataProvider_Failover_ListServices(handler, data) ({ \
    SBUS_CHECK_SYNC((handler), (data), const char *, const char ***); \
    sbus_method_sync("ListServices", \
        &_sbus_sss_args_sssd_DataProvider_Failover_ListServices, \
        NULL, \
        _sbus_sss_invoke_in_s_out_as_send, \
        _sbus_sss_key_s_0, \
        (handler), (data)); \
})

#define SBUS_METHOD_ASYNC_sssd_DataProvider_Failover_ListServices(handler_send, handler_recv, data) ({ \
    SBUS_CHECK_SEND((handler_send), (data), const char *); \
    SBUS_CHECK_RECV((handler_recv), const char ***); \
    sbus_method_async("ListServices", \
        &_sbus_sss_args_sssd_DataProvider_Failover_ListServices, \
        NULL, \
        _sbus_sss_invoke_in_s_out_as_send, \
        _sbus_sss_key_s_0, \
        (handler_send), (handler_recv), (data)); \
})

/* Interface: sssd.ProxyChild.Auth */
#define SBUS_IFACE_sssd_ProxyChild_Auth(methods, signals, properties) ({ \
    sbus_interface("sssd.ProxyChild.Auth", NULL, \
        (methods), (signals), (properties)); \
})

/* Method: sssd.ProxyChild.Auth.PAM */
#define SBUS_METHOD_SYNC_sssd_ProxyChild_Auth_PAM(handler, data) ({ \
    SBUS_CHECK_SYNC((handler), (data), struct pam_data *, struct pam_data **); \
    sbus_method_sync("PAM", \
        &_sbus_sss_args_sssd_ProxyChild_Auth_PAM, \
        NULL, \
        _sbus_sss_invoke_in_pam_data_out_pam_response_send, \
        NULL, \
        (handler), (data)); \
})

#define SBUS_METHOD_ASYNC_sssd_ProxyChild_Auth_PAM(handler_send, handler_recv, data) ({ \
    SBUS_CHECK_SEND((handler_send), (data), struct pam_data *); \
    SBUS_CHECK_RECV((handler_recv), struct pam_data **); \
    sbus_method_async("PAM", \
        &_sbus_sss_args_sssd_ProxyChild_Auth_PAM, \
        NULL, \
        _sbus_sss_invoke_in_pam_data_out_pam_response_send, \
        NULL, \
        (handler_send), (handler_recv), (data)); \
})

/* Interface: sssd.ProxyChild.Client */
#define SBUS_IFACE_sssd_ProxyChild_Client(methods, signals, properties) ({ \
    sbus_interface("sssd.ProxyChild.Client", NULL, \
        (methods), (signals), (properties)); \
})

/* Method: sssd.ProxyChild.Client.Register */
#define SBUS_METHOD_SYNC_sssd_ProxyChild_Client_Register(handler, data) ({ \
    SBUS_CHECK_SYNC((handler), (data), uint32_t); \
    sbus_method_sync("Register", \
        &_sbus_sss_args_sssd_ProxyChild_Client_Register, \
        NULL, \
        _sbus_sss_invoke_in_u_out__send, \
        NULL, \
        (handler), (data)); \
})

#define SBUS_METHOD_ASYNC_sssd_ProxyChild_Client_Register(handler_send, handler_recv, data) ({ \
    SBUS_CHECK_SEND((handler_send), (data), uint32_t); \
    SBUS_CHECK_RECV((handler_recv)); \
    sbus_method_async("Register", \
        &_sbus_sss_args_sssd_ProxyChild_Client_Register, \
        NULL, \
        _sbus_sss_invoke_in_u_out__send, \
        NULL, \
        (handler_send), (handler_recv), (data)); \
})

/* Interface: sssd.Responder.Domain */
#define SBUS_IFACE_sssd_Responder_Domain(methods, signals, properties) ({ \
    sbus_interface("sssd.Responder.Domain", NULL, \
        (methods), (signals), (properties)); \
})

/* Signal: sssd.Responder.Domain.SetActive */
#define SBUS_SIGNAL_EMITS_sssd_Responder_Domain_SetActive() ({ \
    sbus_signal("SetActive", \
        _sbus_sss_args_sssd_Responder_Domain_SetActive, \
        NULL); \
})

#define SBUS_SIGNAL_SYNC_sssd_Responder_Domain_SetActive(path, handler, data) ({ \
    SBUS_CHECK_SYNC((handler), (data), const char *); \
    sbus_listener_sync("sssd.Responder.Domain", "SetActive", (path), \
        _sbus_sss_invoke_in_s_out__send, \
        NULL, \
        (handler), (data)); \
})

#define SBUS_SIGNAL_ASYNC_sssd_Responder_Domain_SetActive(path, handler_send, handler_recv, data) ({ \
    SBUS_CHECK_SEND((handler_send), (data), const char *); \
    SBUS_CHECK_RECV((handler_recv)); \
    sbus_listener_async("sssd.Responder.Domain", "SetActive", (path), \
        _sbus_sss_invoke_in_s_out__send, \
        NULL, \
        (handler_send), (handler_recv), (data)); \
})

/* Signal: sssd.Responder.Domain.SetInconsistent */
#define SBUS_SIGNAL_EMITS_sssd_Responder_Domain_SetInconsistent() ({ \
    sbus_signal("SetInconsistent", \
        _sbus_sss_args_sssd_Responder_Domain_SetInconsistent, \
        NULL); \
})

#define SBUS_SIGNAL_SYNC_sssd_Responder_Domain_SetInconsistent(path, handler, data) ({ \
    SBUS_CHECK_SYNC((handler), (data), const char *); \
    sbus_listener_sync("sssd.Responder.Domain", "SetInconsistent", (path), \
        _sbus_sss_invoke_in_s_out__send, \
        NULL, \
        (handler), (data)); \
})

#define SBUS_SIGNAL_ASYNC_sssd_Responder_Domain_SetInconsistent(path, handler_send, handler_recv, data) ({ \
    SBUS_CHECK_SEND((handler_send), (data), const char *); \
    SBUS_CHECK_RECV((handler_recv)); \
    sbus_listener_async("sssd.Responder.Domain", "SetInconsistent", (path), \
        _sbus_sss_invoke_in_s_out__send, \
        NULL, \
        (handler_send), (handler_recv), (data)); \
})

/* Interface: sssd.Responder.NegativeCache */
#define SBUS_IFACE_sssd_Responder_NegativeCache(methods, signals, properties) ({ \
    sbus_interface("sssd.Responder.NegativeCache", NULL, \
        (methods), (signals), (properties)); \
})

/* Signal: sssd.Responder.NegativeCache.ResetGroups */
#define SBUS_SIGNAL_EMITS_sssd_Responder_NegativeCache_ResetGroups() ({ \
    sbus_signal("ResetGroups", \
        _sbus_sss_args_sssd_Responder_NegativeCache_ResetGroups, \
        NULL); \
})

#define SBUS_SIGNAL_SYNC_sssd_Responder_NegativeCache_ResetGroups(path, handler, data) ({ \
    SBUS_CHECK_SYNC((handler), (data)); \
    sbus_listener_sync("sssd.Responder.NegativeCache", "ResetGroups", (path), \
        _sbus_sss_invoke_in__out__send, \
        _sbus_sss_key_, \
        (handler), (data)); \
})

#define SBUS_SIGNAL_ASYNC_sssd_Responder_NegativeCache_ResetGroups(path, handler_send, handler_recv, data) ({ \
    SBUS_CHECK_SEND((handler_send), (data)); \
    SBUS_CHECK_RECV((handler_recv)); \
    sbus_listener_async("sssd.Responder.NegativeCache", "ResetGroups", (path), \
        _sbus_sss_invoke_in__out__send, \
        _sbus_sss_key_, \
        (handler_send), (handler_recv), (data)); \
})

/* Signal: sssd.Responder.NegativeCache.ResetUsers */
#define SBUS_SIGNAL_EMITS_sssd_Responder_NegativeCache_ResetUsers() ({ \
    sbus_signal("ResetUsers", \
        _sbus_sss_args_sssd_Responder_NegativeCache_ResetUsers, \
        NULL); \
})

#define SBUS_SIGNAL_SYNC_sssd_Responder_NegativeCache_ResetUsers(path, handler, data) ({ \
    SBUS_CHECK_SYNC((handler), (data)); \
    sbus_listener_sync("sssd.Responder.NegativeCache", "ResetUsers", (path), \
        _sbus_sss_invoke_in__out__send, \
        _sbus_sss_key_, \
        (handler), (data)); \
})

#define SBUS_SIGNAL_ASYNC_sssd_Responder_NegativeCache_ResetUsers(path, handler_send, handler_recv, data) ({ \
    SBUS_CHECK_SEND((handler_send), (data)); \
    SBUS_CHECK_RECV((handler_recv)); \
    sbus_listener_async("sssd.Responder.NegativeCache", "ResetUsers", (path), \
        _sbus_sss_invoke_in__out__send, \
        _sbus_sss_key_, \
        (handler_send), (handler_recv), (data)); \
})

/* Interface: sssd.dataprovider */
#define SBUS_IFACE_sssd_dataprovider(methods, signals, properties) ({ \
    sbus_interface("sssd.dataprovider", NULL, \
        (methods), (signals), (properties)); \
})

/* Method: sssd.dataprovider.getAccountDomain */
#define SBUS_METHOD_SYNC_sssd_dataprovider_getAccountDomain(handler, data) ({ \
    SBUS_CHECK_SYNC((handler), (data), uint32_t, uint32_t, const char *, uint32_t, uint16_t*, uint32_t*, const char **); \
    sbus_method_sync("getAccountDomain", \
        &_sbus_sss_args_sssd_dataprovider_getAccountDomain, \
        NULL, \
        _sbus_sss_invoke_in_uusu_out_qus_send, \
        _sbus_sss_key_uusu_0_1_2, \
        (handler), (data)); \
})

#define SBUS_METHOD_ASYNC_sssd_dataprovider_getAccountDomain(handler_send, handler_recv, data) ({ \
    SBUS_CHECK_SEND((handler_send), (data), uint32_t, uint32_t, const char *, uint32_t); \
    SBUS_CHECK_RECV((handler_recv), uint16_t*, uint32_t*, const char **); \
    sbus_method_async("getAccountDomain", \
        &_sbus_sss_args_sssd_dataprovider_getAccountDomain, \
        NULL, \
        _sbus_sss_invoke_in_uusu_out_qus_send, \
        _sbus_sss_key_uusu_0_1_2, \
        (handler_send), (handler_recv), (data)); \
})

/* Method: sssd.dataprovider.getAccountInfo */
#define SBUS_METHOD_SYNC_sssd_dataprovider_getAccountInfo(handler, data) ({ \
    SBUS_CHECK_SYNC((handler), (data), uint32_t, uint32_t, const char *, const char *, const char *, uint32_t, uint16_t*, uint32_t*, const char **); \
    sbus_method_sync("getAccountInfo", \
        &_sbus_sss_args_sssd_dataprovider_getAccountInfo, \
        NULL, \
        _sbus_sss_invoke_in_uusssu_out_qus_send, \
        _sbus_sss_key_uusssu_0_1_2_3_4, \
        (handler), (data)); \
})

#define SBUS_METHOD_ASYNC_sssd_dataprovider_getAccountInfo(handler_send, handler_recv, data) ({ \
    SBUS_CHECK_SEND((handler_send), (data), uint32_t, uint32_t, const char *, const char *, const char *, uint32_t); \
    SBUS_CHECK_RECV((handler_recv), uint16_t*, uint32_t*, const char **); \
    sbus_method_async("getAccountInfo", \
        &_sbus_sss_args_sssd_dataprovider_getAccountInfo, \
        NULL, \
        _sbus_sss_invoke_in_uusssu_out_qus_send, \
        _sbus_sss_key_uusssu_0_1_2_3_4, \
        (handler_send), (handler_recv), (data)); \
})

/* Method: sssd.dataprovider.getDomains */
#define SBUS_METHOD_SYNC_sssd_dataprovider_getDomains(handler, data) ({ \
    SBUS_CHECK_SYNC((handler), (data), const char *, uint16_t*, uint32_t*, const char **); \
    sbus_method_sync("getDomains", \
        &_sbus_sss_args_sssd_dataprovider_getDomains, \
        NULL, \
        _sbus_sss_invoke_in_s_out_qus_send, \
        _sbus_sss_key_s_0, \
        (handler), (data)); \
})

#define SBUS_METHOD_ASYNC_sssd_dataprovider_getDomains(handler_send, handler_recv, data) ({ \
    SBUS_CHECK_SEND((handler_send), (data), const char *); \
    SBUS_CHECK_RECV((handler_recv), uint16_t*, uint32_t*, const char **); \
    sbus_method_async("getDomains", \
        &_sbus_sss_args_sssd_dataprovider_getDomains, \
        NULL, \
        _sbus_sss_invoke_in_s_out_qus_send, \
        _sbus_sss_key_s_0, \
        (handler_send), (handler_recv), (data)); \
})

/* Method: sssd.dataprovider.hostHandler */
#define SBUS_METHOD_SYNC_sssd_dataprovider_hostHandler(handler, data) ({ \
    SBUS_CHECK_SYNC((handler), (data), uint32_t, const char *, const char *, uint32_t, uint16_t*, uint32_t*, const char **); \
    sbus_method_sync("hostHandler", \
        &_sbus_sss_args_sssd_dataprovider_hostHandler, \
        NULL, \
        _sbus_sss_invoke_in_ussu_out_qus_send, \
        _sbus_sss_key_ussu_0_1, \
        (handler), (data)); \
})

#define SBUS_METHOD_ASYNC_sssd_dataprovider_hostHandler(handler_send, handler_recv, data) ({ \
    SBUS_CHECK_SEND((handler_send), (data), uint32_t, const char *, const char *, uint32_t); \
    SBUS_CHECK_RECV((handler_recv), uint16_t*, uint32_t*, const char **); \
    sbus_method_async("hostHandler", \
        &_sbus_sss_args_sssd_dataprovider_hostHandler, \
        NULL, \
        _sbus_sss_invoke_in_ussu_out_qus_send, \
        _sbus_sss_key_ussu_0_1, \
        (handler_send), (handler_recv), (data)); \
})

/* Method: sssd.dataprovider.pamHandler */
#define SBUS_METHOD_SYNC_sssd_dataprovider_pamHandler(handler, data) ({ \
    SBUS_CHECK_SYNC((handler), (data), struct pam_data *, struct pam_data **); \
    sbus_method_sync("pamHandler", \
        &_sbus_sss_args_sssd_dataprovider_pamHandler, \
        NULL, \
        _sbus_sss_invoke_in_pam_data_out_pam_response_send, \
        NULL, \
        (handler), (data)); \
})

#define SBUS_METHOD_ASYNC_sssd_dataprovider_pamHandler(handler_send, handler_recv, data) ({ \
    SBUS_CHECK_SEND((handler_send), (data), struct pam_data *); \
    SBUS_CHECK_RECV((handler_recv), struct pam_data **); \
    sbus_method_async("pamHandler", \
        &_sbus_sss_args_sssd_dataprovider_pamHandler, \
        NULL, \
        _sbus_sss_invoke_in_pam_data_out_pam_response_send, \
        NULL, \
        (handler_send), (handler_recv), (data)); \
})

/* Method: sssd.dataprovider.resolverHandler */
#define SBUS_METHOD_SYNC_sssd_dataprovider_resolverHandler(handler, data) ({ \
    SBUS_CHECK_SYNC((handler), (data), uint32_t, uint32_t, uint32_t, const char *, uint32_t, uint16_t*, uint32_t*, const char **); \
    sbus_method_sync("resolverHandler", \
        &_sbus_sss_args_sssd_dataprovider_resolverHandler, \
        NULL, \
        _sbus_sss_invoke_in_uuusu_out_qus_send, \
        _sbus_sss_key_uuusu_0_1_2_3, \
        (handler), (data)); \
})

#define SBUS_METHOD_ASYNC_sssd_dataprovider_resolverHandler(handler_send, handler_recv, data) ({ \
    SBUS_CHECK_SEND((handler_send), (data), uint32_t, uint32_t, uint32_t, const char *, uint32_t); \
    SBUS_CHECK_RECV((handler_recv), uint16_t*, uint32_t*, const char **); \
    sbus_method_async("resolverHandler", \
        &_sbus_sss_args_sssd_dataprovider_resolverHandler, \
        NULL, \
        _sbus_sss_invoke_in_uuusu_out_qus_send, \
        _sbus_sss_key_uuusu_0_1_2_3, \
        (handler_send), (handler_recv), (data)); \
})

/* Method: sssd.dataprovider.sudoHandler */
#define SBUS_METHOD_SYNC_sssd_dataprovider_sudoHandler(handler, data) ({ \
    SBUS_CHECK_SYNC((handler), (data), DBusMessageIter *, uint16_t*, uint32_t*, const char **); \
    sbus_method_sync("sudoHandler", \
        &_sbus_sss_args_sssd_dataprovider_sudoHandler, \
        NULL, \
        _sbus_sss_invoke_in_raw_out_qus_send, \
        NULL, \
        (handler), (data)); \
})

#define SBUS_METHOD_ASYNC_sssd_dataprovider_sudoHandler(handler_send, handler_recv, data) ({ \
    SBUS_CHECK_SEND((handler_send), (data), DBusMessageIter *); \
    SBUS_CHECK_RECV((handler_recv), uint16_t*, uint32_t*, const char **); \
    sbus_method_async("sudoHandler", \
        &_sbus_sss_args_sssd_dataprovider_sudoHandler, \
        NULL, \
        _sbus_sss_invoke_in_raw_out_qus_send, \
        NULL, \
        (handler_send), (handler_recv), (data)); \
})

/* Interface: sssd.monitor */
#define SBUS_IFACE_sssd_monitor(methods, signals, properties) ({ \
    sbus_interface("sssd.monitor", NULL, \
        (methods), (signals), (properties)); \
})

/* Method: sssd.monitor.RegisterService */
#define SBUS_METHOD_SYNC_sssd_monitor_RegisterService(handler, data) ({ \
    SBUS_CHECK_SYNC((handler), (data), const char *, uint16_t, uint16_t, uint16_t*); \
    sbus_method_sync("RegisterService", \
        &_sbus_sss_args_sssd_monitor_RegisterService, \
        NULL, \
        _sbus_sss_invoke_in_sqq_out_q_send, \
        NULL, \
        (handler), (data)); \
})

#define SBUS_METHOD_ASYNC_sssd_monitor_RegisterService(handler_send, handler_recv, data) ({ \
    SBUS_CHECK_SEND((handler_send), (data), const char *, uint16_t, uint16_t); \
    SBUS_CHECK_RECV((handler_recv), uint16_t*); \
    sbus_method_async("RegisterService", \
        &_sbus_sss_args_sssd_monitor_RegisterService, \
        NULL, \
        _sbus_sss_invoke_in_sqq_out_q_send, \
        NULL, \
        (handler_send), (handler_recv), (data)); \
})

/* Interface: sssd.nss.MemoryCache */
#define SBUS_IFACE_sssd_nss_MemoryCache(methods, signals, properties) ({ \
    sbus_interface("sssd.nss.MemoryCache", NULL, \
        (methods), (signals), (properties)); \
})

/* Method: sssd.nss.MemoryCache.UpdateInitgroups */
#define SBUS_METHOD_SYNC_sssd_nss_MemoryCache_UpdateInitgroups(handler, data) ({ \
    SBUS_CHECK_SYNC((handler), (data), const char *, const char *, uint32_t *); \
    sbus_method_sync("UpdateInitgroups", \
        &_sbus_sss_args_sssd_nss_MemoryCache_UpdateInitgroups, \
        NULL, \
        _sbus_sss_invoke_in_ssau_out__send, \
        NULL, \
        (handler), (data)); \
})

#define SBUS_METHOD_ASYNC_sssd_nss_MemoryCache_UpdateInitgroups(handler_send, handler_recv, data) ({ \
    SBUS_CHECK_SEND((handler_send), (data), const char *, const char *, uint32_t *); \
    SBUS_CHECK_RECV((handler_recv)); \
    sbus_method_async("UpdateInitgroups", \
        &_sbus_sss_args_sssd_nss_MemoryCache_UpdateInitgroups, \
        NULL, \
        _sbus_sss_invoke_in_ssau_out__send, \
        NULL, \
        (handler_send), (handler_recv), (data)); \
})

/* Signal: sssd.nss.MemoryCache.InvalidateAllGroups */
#define SBUS_SIGNAL_EMITS_sssd_nss_MemoryCache_InvalidateAllGroups() ({ \
    sbus_signal("InvalidateAllGroups", \
        _sbus_sss_args_sssd_nss_MemoryCache_InvalidateAllGroups, \
        NULL); \
})

#define SBUS_SIGNAL_SYNC_sssd_nss_MemoryCache_InvalidateAllGroups(path, handler, data) ({ \
    SBUS_CHECK_SYNC((handler), (data)); \
    sbus_listener_sync("sssd.nss.MemoryCache", "InvalidateAllGroups", (path), \
        _sbus_sss_invoke_in__out__send, \
        NULL, \
        (handler), (data)); \
})

#define SBUS_SIGNAL_ASYNC_sssd_nss_MemoryCache_InvalidateAllGroups(path, handler_send, handler_recv, data) ({ \
    SBUS_CHECK_SEND((handler_send), (data)); \
    SBUS_CHECK_RECV((handler_recv)); \
    sbus_listener_async("sssd.nss.MemoryCache", "InvalidateAllGroups", (path), \
        _sbus_sss_invoke_in__out__send, \
        NULL, \
        (handler_send), (handler_recv), (data)); \
})

/* Signal: sssd.nss.MemoryCache.InvalidateAllInitgroups */
#define SBUS_SIGNAL_EMITS_sssd_nss_MemoryCache_InvalidateAllInitgroups() ({ \
    sbus_signal("InvalidateAllInitgroups", \
        _sbus_sss_args_sssd_nss_MemoryCache_InvalidateAllInitgroups, \
        NULL); \
})

#define SBUS_SIGNAL_SYNC_sssd_nss_MemoryCache_InvalidateAllInitgroups(path, handler, data) ({ \
    SBUS_CHECK_SYNC((handler), (data)); \
    sbus_listener_sync("sssd.nss.MemoryCache", "InvalidateAllInitgroups", (path), \
        _sbus_sss_invoke_in__out__send, \
        NULL, \
        (handler), (data)); \
})

#define SBUS_SIGNAL_ASYNC_sssd_nss_MemoryCache_InvalidateAllInitgroups(path, handler_send, handler_recv, data) ({ \
    SBUS_CHECK_SEND((handler_send), (data)); \
    SBUS_CHECK_RECV((handler_recv)); \
    sbus_listener_async("sssd.nss.MemoryCache", "InvalidateAllInitgroups", (path), \
        _sbus_sss_invoke_in__out__send, \
        NULL, \
        (handler_send), (handler_recv), (data)); \
})

/* Signal: sssd.nss.MemoryCache.InvalidateAllUsers */
#define SBUS_SIGNAL_EMITS_sssd_nss_MemoryCache_InvalidateAllUsers() ({ \
    sbus_signal("InvalidateAllUsers", \
        _sbus_sss_args_sssd_nss_MemoryCache_InvalidateAllUsers, \
        NULL); \
})

#define SBUS_SIGNAL_SYNC_sssd_nss_MemoryCache_InvalidateAllUsers(path, handler, data) ({ \
    SBUS_CHECK_SYNC((handler), (data)); \
    sbus_listener_sync("sssd.nss.MemoryCache", "InvalidateAllUsers", (path), \
        _sbus_sss_invoke_in__out__send, \
        NULL, \
        (handler), (data)); \
})

#define SBUS_SIGNAL_ASYNC_sssd_nss_MemoryCache_InvalidateAllUsers(path, handler_send, handler_recv, data) ({ \
    SBUS_CHECK_SEND((handler_send), (data)); \
    SBUS_CHECK_RECV((handler_recv)); \
    sbus_listener_async("sssd.nss.MemoryCache", "InvalidateAllUsers", (path), \
        _sbus_sss_invoke_in__out__send, \
        NULL, \
        (handler_send), (handler_recv), (data)); \
})

/* Signal: sssd.nss.MemoryCache.InvalidateGroupById */
#define SBUS_SIGNAL_EMITS_sssd_nss_MemoryCache_InvalidateGroupById() ({ \
    sbus_signal("InvalidateGroupById", \
        _sbus_sss_args_sssd_nss_MemoryCache_InvalidateGroupById, \
        NULL); \
})

#define SBUS_SIGNAL_SYNC_sssd_nss_MemoryCache_InvalidateGroupById(path, handler, data) ({ \
    SBUS_CHECK_SYNC((handler), (data), uint32_t); \
    sbus_listener_sync("sssd.nss.MemoryCache", "InvalidateGroupById", (path), \
        _sbus_sss_invoke_in_u_out__send, \
        _sbus_sss_key_u_0, \
        (handler), (data)); \
})

#define SBUS_SIGNAL_ASYNC_sssd_nss_MemoryCache_InvalidateGroupById(path, handler_send, handler_recv, data) ({ \
    SBUS_CHECK_SEND((handler_send), (data), uint32_t); \
    SBUS_CHECK_RECV((handler_recv)); \
    sbus_listener_async("sssd.nss.MemoryCache", "InvalidateGroupById", (path), \
        _sbus_sss_invoke_in_u_out__send, \
        _sbus_sss_key_u_0, \
        (handler_send), (handler_recv), (data)); \
})

/* Interface: sssd.service */
#define SBUS_IFACE_sssd_service(methods, signals, properties) ({ \
    sbus_interface("sssd.service", NULL, \
        (methods), (signals), (properties)); \
})

/* Method: sssd.service.clearEnumCache */
#define SBUS_METHOD_SYNC_sssd_service_clearEnumCache(handler, data) ({ \
    SBUS_CHECK_SYNC((handler), (data)); \
    sbus_method_sync("clearEnumCache", \
        &_sbus_sss_args_sssd_service_clearEnumCache, \
        NULL, \
        _sbus_sss_invoke_in__out__send, \
        NULL, \
        (handler), (data)); \
})

#define SBUS_METHOD_ASYNC_sssd_service_clearEnumCache(handler_send, handler_recv, data) ({ \
    SBUS_CHECK_SEND((handler_send), (data)); \
    SBUS_CHECK_RECV((handler_recv)); \
    sbus_method_async("clearEnumCache", \
        &_sbus_sss_args_sssd_service_clearEnumCache, \
        NULL, \
        _sbus_sss_invoke_in__out__send, \
        NULL, \
        (handler_send), (handler_recv), (data)); \
})

/* Method: sssd.service.clearMemcache */
#define SBUS_METHOD_SYNC_sssd_service_clearMemcache(handler, data) ({ \
    SBUS_CHECK_SYNC((handler), (data)); \
    sbus_method_sync("clearMemcache", \
        &_sbus_sss_args_sssd_service_clearMemcache, \
        NULL, \
        _sbus_sss_invoke_in__out__send, \
        NULL, \
        (handler), (data)); \
})

#define SBUS_METHOD_ASYNC_sssd_service_clearMemcache(handler_send, handler_recv, data) ({ \
    SBUS_CHECK_SEND((handler_send), (data)); \
    SBUS_CHECK_RECV((handler_recv)); \
    sbus_method_async("clearMemcache", \
        &_sbus_sss_args_sssd_service_clearMemcache, \
        NULL, \
        _sbus_sss_invoke_in__out__send, \
        NULL, \
        (handler_send), (handler_recv), (data)); \
})

/* Method: sssd.service.clearNegcache */
#define SBUS_METHOD_SYNC_sssd_service_clearNegcache(handler, data) ({ \
    SBUS_CHECK_SYNC((handler), (data)); \
    sbus_method_sync("clearNegcache", \
        &_sbus_sss_args_sssd_service_clearNegcache, \
        NULL, \
        _sbus_sss_invoke_in__out__send, \
        NULL, \
        (handler), (data)); \
})

#define SBUS_METHOD_ASYNC_sssd_service_clearNegcache(handler_send, handler_recv, data) ({ \
    SBUS_CHECK_SEND((handler_send), (data)); \
    SBUS_CHECK_RECV((handler_recv)); \
    sbus_method_async("clearNegcache", \
        &_sbus_sss_args_sssd_service_clearNegcache, \
        NULL, \
        _sbus_sss_invoke_in__out__send, \
        NULL, \
        (handler_send), (handler_recv), (data)); \
})

/* Method: sssd.service.goOffline */
#define SBUS_METHOD_SYNC_sssd_service_goOffline(handler, data) ({ \
    SBUS_CHECK_SYNC((handler), (data)); \
    sbus_method_sync("goOffline", \
        &_sbus_sss_args_sssd_service_goOffline, \
        NULL, \
        _sbus_sss_invoke_in__out__send, \
        NULL, \
        (handler), (data)); \
})

#define SBUS_METHOD_ASYNC_sssd_service_goOffline(handler_send, handler_recv, data) ({ \
    SBUS_CHECK_SEND((handler_send), (data)); \
    SBUS_CHECK_RECV((handler_recv)); \
    sbus_method_async("goOffline", \
        &_sbus_sss_args_sssd_service_goOffline, \
        NULL, \
        _sbus_sss_invoke_in__out__send, \
        NULL, \
        (handler_send), (handler_recv), (data)); \
})

/* Method: sssd.service.resetOffline */
#define SBUS_METHOD_SYNC_sssd_service_resetOffline(handler, data) ({ \
    SBUS_CHECK_SYNC((handler), (data)); \
    sbus_method_sync("resetOffline", \
        &_sbus_sss_args_sssd_service_resetOffline, \
        NULL, \
        _sbus_sss_invoke_in__out__send, \
        NULL, \
        (handler), (data)); \
})

#define SBUS_METHOD_ASYNC_sssd_service_resetOffline(handler_send, handler_recv, data) ({ \
    SBUS_CHECK_SEND((handler_send), (data)); \
    SBUS_CHECK_RECV((handler_recv)); \
    sbus_method_async("resetOffline", \
        &_sbus_sss_args_sssd_service_resetOffline, \
        NULL, \
        _sbus_sss_invoke_in__out__send, \
        NULL, \
        (handler_send), (handler_recv), (data)); \
})

/* Method: sssd.service.rotateLogs */
#define SBUS_METHOD_SYNC_sssd_service_rotateLogs(handler, data) ({ \
    SBUS_CHECK_SYNC((handler), (data)); \
    sbus_method_sync("rotateLogs", \
        &_sbus_sss_args_sssd_service_rotateLogs, \
        NULL, \
        _sbus_sss_invoke_in__out__send, \
        NULL, \
        (handler), (data)); \
})

#define SBUS_METHOD_ASYNC_sssd_service_rotateLogs(handler_send, handler_recv, data) ({ \
    SBUS_CHECK_SEND((handler_send), (data)); \
    SBUS_CHECK_RECV((handler_recv)); \
    sbus_method_async("rotateLogs", \
        &_sbus_sss_args_sssd_service_rotateLogs, \
        NULL, \
        _sbus_sss_invoke_in__out__send, \
        NULL, \
        (handler_send), (handler_recv), (data)); \
})

/* Method: sssd.service.sysbusReconnect */
#define SBUS_METHOD_SYNC_sssd_service_sysbusReconnect(handler, data) ({ \
    SBUS_CHECK_SYNC((handler), (data)); \
    sbus_method_sync("sysbusReconnect", \
        &_sbus_sss_args_sssd_service_sysbusReconnect, \
        NULL, \
        _sbus_sss_invoke_in__out__send, \
        NULL, \
        (handler), (data)); \
})

#define SBUS_METHOD_ASYNC_sssd_service_sysbusReconnect(handler_send, handler_recv, data) ({ \
    SBUS_CHECK_SEND((handler_send), (data)); \
    SBUS_CHECK_RECV((handler_recv)); \
    sbus_method_async("sysbusReconnect", \
        &_sbus_sss_args_sssd_service_sysbusReconnect, \
        NULL, \
        _sbus_sss_invoke_in__out__send, \
        NULL, \
        (handler_send), (handler_recv), (data)); \
})

/* Property: sssd.service.debug_level */
#define SBUS_GETTER_SYNC_sssd_service_debug_level(handler, data) ({ \
    SBUS_CHECK_SYNC((handler), (data), uint32_t*); \
    sbus_property_sync("debug_level", "u", SBUS_PROPERTY_READABLE, \
       NULL, \
       _sbus_sss_invoke_in__out_u_send, \
       (handler), (data)); \
})

#define SBUS_GETTER_ASYNC_sssd_service_debug_level(handler_send, handler_recv, data) ({ \
    SBUS_CHECK_SEND((handler_send), (data)); \
    SBUS_CHECK_RECV((handler_recv), uint32_t*); \
    sbus_property_async("debug_level", "u", SBUS_PROPERTY_READABLE, \
       NULL, \
       _sbus_sss_invoke_in__out_u_send, \
       (handler_send), (handler_recv), (data)); \
})

#define SBUS_SETTER_SYNC_sssd_service_debug_level(handler, data) ({\
    SBUS_CHECK_SYNC((handler), (data), uint32_t); \
    sbus_property_sync("debug_level", "u", SBUS_PROPERTY_WRITABLE, \
       NULL, \
       _sbus_sss_invoke_in_u_out__send, \
       (handler), (data)); \
})

#define SBUS_SETTER_ASYNC_sssd_service_debug_level(handler_send, handler_recv, data) ({ \
    SBUS_CHECK_SEND((handler_send), (data), uint32_t); \
    SBUS_CHECK_RECV((handler_recv)); \
    sbus_property_async("debug_level", "u", SBUS_PROPERTY_WRITABLE, \
       NULL, \
       _sbus_sss_invoke_in_u_out__send, \
       (handler_send), (handler_recv), (data)); \
})

#endif /* _SBUS_SSS_INTERFACE_H_ */
