# coding: utf-8

"""
    Ketra Lighting API

    Control your Ketra lights  # noqa: E501

    The version of the OpenAPI document: 1.4.0
    Generated by: https://openapi-generator.tech
"""


from __future__ import absolute_import

import re  # noqa: F401

# python 2 and python 3 compatibility library
import six

from aioketraapi.api_client import ApiClient
from aioketraapi.exceptions import (  # noqa: F401
    ApiTypeError,
    ApiValueError
)


class KeypadOperationsApi(object):
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None):
        if api_client is None:
            api_client = ApiClient()
        self.api_client = api_client

    def activate_button_post(self, keypad_name, button_name, level, **kwargs):  # noqa: E501
        """Activate a button  # noqa: E501

        Activates the scene or show represented by the button   # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.activate_button_post(keypad_name, button_name, level, async_req=True)
        >>> result = thread.get()

        :param keypad_name: Specifies a keypad name (required)
        :type keypad_name: str
        :param button_name: Specifies a button name (required)
        :type button_name: str
        :param level: The level (required)
        :type level: Level
        :param basicauthuser: Username to use in place of username in basic authentication header.  For a secure installation, this value is ignored but still must be supplied unless a basic authentication header is sent with the request.
        :type basicauthuser: str
        :param basicauthpassword: Password to use in place of password in basic authentication header. For a secure installation, this should be an oauth token for a user with access to the installation.  If a basic authentication header is sent, this parameter is ignored.  If no basic authentication header is sent, this parameter as well as the basicauthuser parameter must be supplied if the hub is a member of a secure installation.
        :type basicauthpassword: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: InlineResponse2009
        """
        kwargs['_return_http_data_only'] = True
        return self.activate_button_post_with_http_info(keypad_name, button_name, level, **kwargs)  # noqa: E501

    def activate_button_post_with_http_info(self, keypad_name, button_name, level, **kwargs):  # noqa: E501
        """Activate a button  # noqa: E501

        Activates the scene or show represented by the button   # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.activate_button_post_with_http_info(keypad_name, button_name, level, async_req=True)
        >>> result = thread.get()

        :param keypad_name: Specifies a keypad name (required)
        :type keypad_name: str
        :param button_name: Specifies a button name (required)
        :type button_name: str
        :param level: The level (required)
        :type level: Level
        :param basicauthuser: Username to use in place of username in basic authentication header.  For a secure installation, this value is ignored but still must be supplied unless a basic authentication header is sent with the request.
        :type basicauthuser: str
        :param basicauthpassword: Password to use in place of password in basic authentication header. For a secure installation, this should be an oauth token for a user with access to the installation.  If a basic authentication header is sent, this parameter is ignored.  If no basic authentication header is sent, this parameter as well as the basicauthuser parameter must be supplied if the hub is a member of a secure installation.
        :type basicauthpassword: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(InlineResponse2009, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'keypad_name',
            'button_name',
            'level',
            'basicauthuser',
            'basicauthpassword'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method activate_button_post" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'keypad_name' is set
        if self.api_client.client_side_validation and ('keypad_name' not in local_var_params or  # noqa: E501
                                                        local_var_params['keypad_name'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `keypad_name` when calling `activate_button_post`")  # noqa: E501
        # verify the required parameter 'button_name' is set
        if self.api_client.client_side_validation and ('button_name' not in local_var_params or  # noqa: E501
                                                        local_var_params['button_name'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `button_name` when calling `activate_button_post`")  # noqa: E501
        # verify the required parameter 'level' is set
        if self.api_client.client_side_validation and ('level' not in local_var_params or  # noqa: E501
                                                        local_var_params['level'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `level` when calling `activate_button_post`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'basicauthuser' in local_var_params and local_var_params['basicauthuser'] is not None:  # noqa: E501
            query_params.append(('basicauthuser', local_var_params['basicauthuser']))  # noqa: E501
        if 'basicauthpassword' in local_var_params and local_var_params['basicauthpassword'] is not None:  # noqa: E501
            query_params.append(('basicauthpassword', local_var_params['basicauthpassword']))  # noqa: E501
        if 'keypad_name' in local_var_params and local_var_params['keypad_name'] is not None:  # noqa: E501
            query_params.append(('KeypadName', local_var_params['keypad_name']))  # noqa: E501
        if 'button_name' in local_var_params and local_var_params['button_name'] is not None:  # noqa: E501
            query_params.append(('ButtonName', local_var_params['button_name']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'level' in local_var_params:
            body_params = local_var_params['level']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['basicAuth']  # noqa: E501

        return self.api_client.call_api(
            '/ActivateButton', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse2009',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def deactivate_button_post(self, keypad_name, button_name, level, **kwargs):  # noqa: E501
        """Deactivate a button  # noqa: E501

        Deactivates the scene or show represented by the button   # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.deactivate_button_post(keypad_name, button_name, level, async_req=True)
        >>> result = thread.get()

        :param keypad_name: Specifies a keypad name (required)
        :type keypad_name: str
        :param button_name: Specifies a button name (required)
        :type button_name: str
        :param level: The level (required)
        :type level: Level
        :param basicauthuser: Username to use in place of username in basic authentication header.  For a secure installation, this value is ignored but still must be supplied unless a basic authentication header is sent with the request.
        :type basicauthuser: str
        :param basicauthpassword: Password to use in place of password in basic authentication header. For a secure installation, this should be an oauth token for a user with access to the installation.  If a basic authentication header is sent, this parameter is ignored.  If no basic authentication header is sent, this parameter as well as the basicauthuser parameter must be supplied if the hub is a member of a secure installation.
        :type basicauthpassword: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: InlineResponse2009
        """
        kwargs['_return_http_data_only'] = True
        return self.deactivate_button_post_with_http_info(keypad_name, button_name, level, **kwargs)  # noqa: E501

    def deactivate_button_post_with_http_info(self, keypad_name, button_name, level, **kwargs):  # noqa: E501
        """Deactivate a button  # noqa: E501

        Deactivates the scene or show represented by the button   # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.deactivate_button_post_with_http_info(keypad_name, button_name, level, async_req=True)
        >>> result = thread.get()

        :param keypad_name: Specifies a keypad name (required)
        :type keypad_name: str
        :param button_name: Specifies a button name (required)
        :type button_name: str
        :param level: The level (required)
        :type level: Level
        :param basicauthuser: Username to use in place of username in basic authentication header.  For a secure installation, this value is ignored but still must be supplied unless a basic authentication header is sent with the request.
        :type basicauthuser: str
        :param basicauthpassword: Password to use in place of password in basic authentication header. For a secure installation, this should be an oauth token for a user with access to the installation.  If a basic authentication header is sent, this parameter is ignored.  If no basic authentication header is sent, this parameter as well as the basicauthuser parameter must be supplied if the hub is a member of a secure installation.
        :type basicauthpassword: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(InlineResponse2009, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'keypad_name',
            'button_name',
            'level',
            'basicauthuser',
            'basicauthpassword'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method deactivate_button_post" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'keypad_name' is set
        if self.api_client.client_side_validation and ('keypad_name' not in local_var_params or  # noqa: E501
                                                        local_var_params['keypad_name'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `keypad_name` when calling `deactivate_button_post`")  # noqa: E501
        # verify the required parameter 'button_name' is set
        if self.api_client.client_side_validation and ('button_name' not in local_var_params or  # noqa: E501
                                                        local_var_params['button_name'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `button_name` when calling `deactivate_button_post`")  # noqa: E501
        # verify the required parameter 'level' is set
        if self.api_client.client_side_validation and ('level' not in local_var_params or  # noqa: E501
                                                        local_var_params['level'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `level` when calling `deactivate_button_post`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'basicauthuser' in local_var_params and local_var_params['basicauthuser'] is not None:  # noqa: E501
            query_params.append(('basicauthuser', local_var_params['basicauthuser']))  # noqa: E501
        if 'basicauthpassword' in local_var_params and local_var_params['basicauthpassword'] is not None:  # noqa: E501
            query_params.append(('basicauthpassword', local_var_params['basicauthpassword']))  # noqa: E501
        if 'keypad_name' in local_var_params and local_var_params['keypad_name'] is not None:  # noqa: E501
            query_params.append(('KeypadName', local_var_params['keypad_name']))  # noqa: E501
        if 'button_name' in local_var_params and local_var_params['button_name'] is not None:  # noqa: E501
            query_params.append(('ButtonName', local_var_params['button_name']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'level' in local_var_params:
            body_params = local_var_params['level']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['basicAuth']  # noqa: E501

        return self.api_client.call_api(
            '/DeactivateButton', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse2009',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def keypads_get(self, **kwargs):  # noqa: E501
        """Get keypads  # noqa: E501

        Gets the list of Ketra keypads.  By default, unless the includeall parameter is provided and set to true, cascaded and mirrored keypads are not returned in the list. However, the buttons of cascaded keypads are returned with their respective master keypad.   # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.keypads_get(async_req=True)
        >>> result = thread.get()

        :param basicauthuser: Username to use in place of username in basic authentication header.  For a secure installation, this value is ignored but still must be supplied unless a basic authentication header is sent with the request.
        :type basicauthuser: str
        :param basicauthpassword: Password to use in place of password in basic authentication header. For a secure installation, this should be an oauth token for a user with access to the installation.  If a basic authentication header is sent, this parameter is ignored.  If no basic authentication header is sent, this parameter as well as the basicauthuser parameter must be supplied if the hub is a member of a secure installation.
        :type basicauthpassword: str
        :param name: If specified, returns only the keypads matching the name provided
        :type name: str
        :param includeall: if true, cascaded and mirrored keypads will be returned in the list.  If false or the parameter is not provided, cascaded keypad buttons will be returned as children of their master keypad.
        :type includeall: bool
        :param nobuttons: if true, the buttons array will not be populated and only the keypad objects will be returned.  For an installation with a large number of keypads this can be much quicker than returning the full set of keypads along with all buttons.
        :type nobuttons: bool
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: InlineResponse2008
        """
        kwargs['_return_http_data_only'] = True
        return self.keypads_get_with_http_info(**kwargs)  # noqa: E501

    def keypads_get_with_http_info(self, **kwargs):  # noqa: E501
        """Get keypads  # noqa: E501

        Gets the list of Ketra keypads.  By default, unless the includeall parameter is provided and set to true, cascaded and mirrored keypads are not returned in the list. However, the buttons of cascaded keypads are returned with their respective master keypad.   # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.keypads_get_with_http_info(async_req=True)
        >>> result = thread.get()

        :param basicauthuser: Username to use in place of username in basic authentication header.  For a secure installation, this value is ignored but still must be supplied unless a basic authentication header is sent with the request.
        :type basicauthuser: str
        :param basicauthpassword: Password to use in place of password in basic authentication header. For a secure installation, this should be an oauth token for a user with access to the installation.  If a basic authentication header is sent, this parameter is ignored.  If no basic authentication header is sent, this parameter as well as the basicauthuser parameter must be supplied if the hub is a member of a secure installation.
        :type basicauthpassword: str
        :param name: If specified, returns only the keypads matching the name provided
        :type name: str
        :param includeall: if true, cascaded and mirrored keypads will be returned in the list.  If false or the parameter is not provided, cascaded keypad buttons will be returned as children of their master keypad.
        :type includeall: bool
        :param nobuttons: if true, the buttons array will not be populated and only the keypad objects will be returned.  For an installation with a large number of keypads this can be much quicker than returning the full set of keypads along with all buttons.
        :type nobuttons: bool
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(InlineResponse2008, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'basicauthuser',
            'basicauthpassword',
            'name',
            'includeall',
            'nobuttons'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method keypads_get" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'basicauthuser' in local_var_params and local_var_params['basicauthuser'] is not None:  # noqa: E501
            query_params.append(('basicauthuser', local_var_params['basicauthuser']))  # noqa: E501
        if 'basicauthpassword' in local_var_params and local_var_params['basicauthpassword'] is not None:  # noqa: E501
            query_params.append(('basicauthpassword', local_var_params['basicauthpassword']))  # noqa: E501
        if 'name' in local_var_params and local_var_params['name'] is not None:  # noqa: E501
            query_params.append(('name', local_var_params['name']))  # noqa: E501
        if 'includeall' in local_var_params and local_var_params['includeall'] is not None:  # noqa: E501
            query_params.append(('includeall', local_var_params['includeall']))  # noqa: E501
        if 'nobuttons' in local_var_params and local_var_params['nobuttons'] is not None:  # noqa: E501
            query_params.append(('nobuttons', local_var_params['nobuttons']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['basicAuth']  # noqa: E501

        return self.api_client.call_api(
            '/Keypads', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse2008',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def keypads_keypad_id_buttons_button_id_activate_post(self, keypad_id, button_id, level, **kwargs):  # noqa: E501
        """Activate a button  # noqa: E501

        Activates the scene or show represented by the button   # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.keypads_keypad_id_buttons_button_id_activate_post(keypad_id, button_id, level, async_req=True)
        >>> result = thread.get()

        :param keypad_id: The keypad's name or unique identifier (uuid) (required)
        :type keypad_id: str
        :param button_id: The button's name or unique identifier (uuid) (required)
        :type button_id: str
        :param level: The level (required)
        :type level: Level
        :param basicauthuser: Username to use in place of username in basic authentication header.  For a secure installation, this value is ignored but still must be supplied unless a basic authentication header is sent with the request.
        :type basicauthuser: str
        :param basicauthpassword: Password to use in place of password in basic authentication header. For a secure installation, this should be an oauth token for a user with access to the installation.  If a basic authentication header is sent, this parameter is ignored.  If no basic authentication header is sent, this parameter as well as the basicauthuser parameter must be supplied if the hub is a member of a secure installation.
        :type basicauthpassword: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: InlineResponse2009
        """
        kwargs['_return_http_data_only'] = True
        return self.keypads_keypad_id_buttons_button_id_activate_post_with_http_info(keypad_id, button_id, level, **kwargs)  # noqa: E501

    def keypads_keypad_id_buttons_button_id_activate_post_with_http_info(self, keypad_id, button_id, level, **kwargs):  # noqa: E501
        """Activate a button  # noqa: E501

        Activates the scene or show represented by the button   # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.keypads_keypad_id_buttons_button_id_activate_post_with_http_info(keypad_id, button_id, level, async_req=True)
        >>> result = thread.get()

        :param keypad_id: The keypad's name or unique identifier (uuid) (required)
        :type keypad_id: str
        :param button_id: The button's name or unique identifier (uuid) (required)
        :type button_id: str
        :param level: The level (required)
        :type level: Level
        :param basicauthuser: Username to use in place of username in basic authentication header.  For a secure installation, this value is ignored but still must be supplied unless a basic authentication header is sent with the request.
        :type basicauthuser: str
        :param basicauthpassword: Password to use in place of password in basic authentication header. For a secure installation, this should be an oauth token for a user with access to the installation.  If a basic authentication header is sent, this parameter is ignored.  If no basic authentication header is sent, this parameter as well as the basicauthuser parameter must be supplied if the hub is a member of a secure installation.
        :type basicauthpassword: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(InlineResponse2009, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'keypad_id',
            'button_id',
            'level',
            'basicauthuser',
            'basicauthpassword'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method keypads_keypad_id_buttons_button_id_activate_post" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'keypad_id' is set
        if self.api_client.client_side_validation and ('keypad_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['keypad_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `keypad_id` when calling `keypads_keypad_id_buttons_button_id_activate_post`")  # noqa: E501
        # verify the required parameter 'button_id' is set
        if self.api_client.client_side_validation and ('button_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['button_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `button_id` when calling `keypads_keypad_id_buttons_button_id_activate_post`")  # noqa: E501
        # verify the required parameter 'level' is set
        if self.api_client.client_side_validation and ('level' not in local_var_params or  # noqa: E501
                                                        local_var_params['level'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `level` when calling `keypads_keypad_id_buttons_button_id_activate_post`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'keypad_id' in local_var_params:
            path_params['keypad-id'] = local_var_params['keypad_id']  # noqa: E501
        if 'button_id' in local_var_params:
            path_params['button-id'] = local_var_params['button_id']  # noqa: E501

        query_params = []
        if 'basicauthuser' in local_var_params and local_var_params['basicauthuser'] is not None:  # noqa: E501
            query_params.append(('basicauthuser', local_var_params['basicauthuser']))  # noqa: E501
        if 'basicauthpassword' in local_var_params and local_var_params['basicauthpassword'] is not None:  # noqa: E501
            query_params.append(('basicauthpassword', local_var_params['basicauthpassword']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'level' in local_var_params:
            body_params = local_var_params['level']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['basicAuth']  # noqa: E501

        return self.api_client.call_api(
            '/Keypads/{keypad-id}/Buttons/{button-id}/Activate', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse2009',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def keypads_keypad_id_buttons_button_id_deactivate_post(self, keypad_id, button_id, level, **kwargs):  # noqa: E501
        """Deactivate a button  # noqa: E501

        Deactivates the scene or show represented by the button   # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.keypads_keypad_id_buttons_button_id_deactivate_post(keypad_id, button_id, level, async_req=True)
        >>> result = thread.get()

        :param keypad_id: The keypad's name or unique identifier (uuid) (required)
        :type keypad_id: str
        :param button_id: The button's name or unique identifier (uuid) (required)
        :type button_id: str
        :param level: The level (required)
        :type level: Level
        :param basicauthuser: Username to use in place of username in basic authentication header.  For a secure installation, this value is ignored but still must be supplied unless a basic authentication header is sent with the request.
        :type basicauthuser: str
        :param basicauthpassword: Password to use in place of password in basic authentication header. For a secure installation, this should be an oauth token for a user with access to the installation.  If a basic authentication header is sent, this parameter is ignored.  If no basic authentication header is sent, this parameter as well as the basicauthuser parameter must be supplied if the hub is a member of a secure installation.
        :type basicauthpassword: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: InlineResponse2009
        """
        kwargs['_return_http_data_only'] = True
        return self.keypads_keypad_id_buttons_button_id_deactivate_post_with_http_info(keypad_id, button_id, level, **kwargs)  # noqa: E501

    def keypads_keypad_id_buttons_button_id_deactivate_post_with_http_info(self, keypad_id, button_id, level, **kwargs):  # noqa: E501
        """Deactivate a button  # noqa: E501

        Deactivates the scene or show represented by the button   # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.keypads_keypad_id_buttons_button_id_deactivate_post_with_http_info(keypad_id, button_id, level, async_req=True)
        >>> result = thread.get()

        :param keypad_id: The keypad's name or unique identifier (uuid) (required)
        :type keypad_id: str
        :param button_id: The button's name or unique identifier (uuid) (required)
        :type button_id: str
        :param level: The level (required)
        :type level: Level
        :param basicauthuser: Username to use in place of username in basic authentication header.  For a secure installation, this value is ignored but still must be supplied unless a basic authentication header is sent with the request.
        :type basicauthuser: str
        :param basicauthpassword: Password to use in place of password in basic authentication header. For a secure installation, this should be an oauth token for a user with access to the installation.  If a basic authentication header is sent, this parameter is ignored.  If no basic authentication header is sent, this parameter as well as the basicauthuser parameter must be supplied if the hub is a member of a secure installation.
        :type basicauthpassword: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(InlineResponse2009, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'keypad_id',
            'button_id',
            'level',
            'basicauthuser',
            'basicauthpassword'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method keypads_keypad_id_buttons_button_id_deactivate_post" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'keypad_id' is set
        if self.api_client.client_side_validation and ('keypad_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['keypad_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `keypad_id` when calling `keypads_keypad_id_buttons_button_id_deactivate_post`")  # noqa: E501
        # verify the required parameter 'button_id' is set
        if self.api_client.client_side_validation and ('button_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['button_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `button_id` when calling `keypads_keypad_id_buttons_button_id_deactivate_post`")  # noqa: E501
        # verify the required parameter 'level' is set
        if self.api_client.client_side_validation and ('level' not in local_var_params or  # noqa: E501
                                                        local_var_params['level'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `level` when calling `keypads_keypad_id_buttons_button_id_deactivate_post`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'keypad_id' in local_var_params:
            path_params['keypad-id'] = local_var_params['keypad_id']  # noqa: E501
        if 'button_id' in local_var_params:
            path_params['button-id'] = local_var_params['button_id']  # noqa: E501

        query_params = []
        if 'basicauthuser' in local_var_params and local_var_params['basicauthuser'] is not None:  # noqa: E501
            query_params.append(('basicauthuser', local_var_params['basicauthuser']))  # noqa: E501
        if 'basicauthpassword' in local_var_params and local_var_params['basicauthpassword'] is not None:  # noqa: E501
            query_params.append(('basicauthpassword', local_var_params['basicauthpassword']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if 'level' in local_var_params:
            body_params = local_var_params['level']
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # HTTP header `Content-Type`
        header_params['Content-Type'] = self.api_client.select_header_content_type(  # noqa: E501
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['basicAuth']  # noqa: E501

        return self.api_client.call_api(
            '/Keypads/{keypad-id}/Buttons/{button-id}/Deactivate', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse2009',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def keypads_keypad_id_buttons_button_id_get(self, keypad_id, button_id, **kwargs):  # noqa: E501
        """Gets the specified button for a specified keypad  # noqa: E501

        Gets the button specified by {button-id} for the keypad specified by {keypad-id}.   # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.keypads_keypad_id_buttons_button_id_get(keypad_id, button_id, async_req=True)
        >>> result = thread.get()

        :param keypad_id: The keypad's name or unique identifier (uuid) (required)
        :type keypad_id: str
        :param button_id: The button's name or unique identifier (uuid) (required)
        :type button_id: str
        :param basicauthuser: Username to use in place of username in basic authentication header.  For a secure installation, this value is ignored but still must be supplied unless a basic authentication header is sent with the request.
        :type basicauthuser: str
        :param basicauthpassword: Password to use in place of password in basic authentication header. For a secure installation, this should be an oauth token for a user with access to the installation.  If a basic authentication header is sent, this parameter is ignored.  If no basic authentication header is sent, this parameter as well as the basicauthuser parameter must be supplied if the hub is a member of a secure installation.
        :type basicauthpassword: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: InlineResponse20011
        """
        kwargs['_return_http_data_only'] = True
        return self.keypads_keypad_id_buttons_button_id_get_with_http_info(keypad_id, button_id, **kwargs)  # noqa: E501

    def keypads_keypad_id_buttons_button_id_get_with_http_info(self, keypad_id, button_id, **kwargs):  # noqa: E501
        """Gets the specified button for a specified keypad  # noqa: E501

        Gets the button specified by {button-id} for the keypad specified by {keypad-id}.   # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.keypads_keypad_id_buttons_button_id_get_with_http_info(keypad_id, button_id, async_req=True)
        >>> result = thread.get()

        :param keypad_id: The keypad's name or unique identifier (uuid) (required)
        :type keypad_id: str
        :param button_id: The button's name or unique identifier (uuid) (required)
        :type button_id: str
        :param basicauthuser: Username to use in place of username in basic authentication header.  For a secure installation, this value is ignored but still must be supplied unless a basic authentication header is sent with the request.
        :type basicauthuser: str
        :param basicauthpassword: Password to use in place of password in basic authentication header. For a secure installation, this should be an oauth token for a user with access to the installation.  If a basic authentication header is sent, this parameter is ignored.  If no basic authentication header is sent, this parameter as well as the basicauthuser parameter must be supplied if the hub is a member of a secure installation.
        :type basicauthpassword: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(InlineResponse20011, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'keypad_id',
            'button_id',
            'basicauthuser',
            'basicauthpassword'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method keypads_keypad_id_buttons_button_id_get" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'keypad_id' is set
        if self.api_client.client_side_validation and ('keypad_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['keypad_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `keypad_id` when calling `keypads_keypad_id_buttons_button_id_get`")  # noqa: E501
        # verify the required parameter 'button_id' is set
        if self.api_client.client_side_validation and ('button_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['button_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `button_id` when calling `keypads_keypad_id_buttons_button_id_get`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'keypad_id' in local_var_params:
            path_params['keypad-id'] = local_var_params['keypad_id']  # noqa: E501
        if 'button_id' in local_var_params:
            path_params['button-id'] = local_var_params['button_id']  # noqa: E501

        query_params = []
        if 'basicauthuser' in local_var_params and local_var_params['basicauthuser'] is not None:  # noqa: E501
            query_params.append(('basicauthuser', local_var_params['basicauthuser']))  # noqa: E501
        if 'basicauthpassword' in local_var_params and local_var_params['basicauthpassword'] is not None:  # noqa: E501
            query_params.append(('basicauthpassword', local_var_params['basicauthpassword']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['basicAuth']  # noqa: E501

        return self.api_client.call_api(
            '/Keypads/{keypad-id}/Buttons/{button-id}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20011',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def keypads_keypad_id_buttons_button_id_push_button_post(self, keypad_id, button_id, **kwargs):  # noqa: E501
        """Pushes a button  # noqa: E501

        Performs the same action as a physical press of the button.  The action performed is determined by the current state of the button and the type of keypad.   Added in hub firmware version 1.12 (API schema 2).   # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.keypads_keypad_id_buttons_button_id_push_button_post(keypad_id, button_id, async_req=True)
        >>> result = thread.get()

        :param keypad_id: The keypad's name or unique identifier (uuid) (required)
        :type keypad_id: str
        :param button_id: The button's name or unique identifier (uuid) (required)
        :type button_id: str
        :param basicauthuser: Username to use in place of username in basic authentication header.  For a secure installation, this value is ignored but still must be supplied unless a basic authentication header is sent with the request.
        :type basicauthuser: str
        :param basicauthpassword: Password to use in place of password in basic authentication header. For a secure installation, this should be an oauth token for a user with access to the installation.  If a basic authentication header is sent, this parameter is ignored.  If no basic authentication header is sent, this parameter as well as the basicauthuser parameter must be supplied if the hub is a member of a secure installation.
        :type basicauthpassword: str
        :param idempotency_key: optional string to guarantee this action will execute only once on the server.  Set this to a random string  and future requests with the same string will be ignored
        :type idempotency_key: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: InlineResponse2009
        """
        kwargs['_return_http_data_only'] = True
        return self.keypads_keypad_id_buttons_button_id_push_button_post_with_http_info(keypad_id, button_id, **kwargs)  # noqa: E501

    def keypads_keypad_id_buttons_button_id_push_button_post_with_http_info(self, keypad_id, button_id, **kwargs):  # noqa: E501
        """Pushes a button  # noqa: E501

        Performs the same action as a physical press of the button.  The action performed is determined by the current state of the button and the type of keypad.   Added in hub firmware version 1.12 (API schema 2).   # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.keypads_keypad_id_buttons_button_id_push_button_post_with_http_info(keypad_id, button_id, async_req=True)
        >>> result = thread.get()

        :param keypad_id: The keypad's name or unique identifier (uuid) (required)
        :type keypad_id: str
        :param button_id: The button's name or unique identifier (uuid) (required)
        :type button_id: str
        :param basicauthuser: Username to use in place of username in basic authentication header.  For a secure installation, this value is ignored but still must be supplied unless a basic authentication header is sent with the request.
        :type basicauthuser: str
        :param basicauthpassword: Password to use in place of password in basic authentication header. For a secure installation, this should be an oauth token for a user with access to the installation.  If a basic authentication header is sent, this parameter is ignored.  If no basic authentication header is sent, this parameter as well as the basicauthuser parameter must be supplied if the hub is a member of a secure installation.
        :type basicauthpassword: str
        :param idempotency_key: optional string to guarantee this action will execute only once on the server.  Set this to a random string  and future requests with the same string will be ignored
        :type idempotency_key: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(InlineResponse2009, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'keypad_id',
            'button_id',
            'basicauthuser',
            'basicauthpassword',
            'idempotency_key'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method keypads_keypad_id_buttons_button_id_push_button_post" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'keypad_id' is set
        if self.api_client.client_side_validation and ('keypad_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['keypad_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `keypad_id` when calling `keypads_keypad_id_buttons_button_id_push_button_post`")  # noqa: E501
        # verify the required parameter 'button_id' is set
        if self.api_client.client_side_validation and ('button_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['button_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `button_id` when calling `keypads_keypad_id_buttons_button_id_push_button_post`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'keypad_id' in local_var_params:
            path_params['keypad-id'] = local_var_params['keypad_id']  # noqa: E501
        if 'button_id' in local_var_params:
            path_params['button-id'] = local_var_params['button_id']  # noqa: E501

        query_params = []
        if 'basicauthuser' in local_var_params and local_var_params['basicauthuser'] is not None:  # noqa: E501
            query_params.append(('basicauthuser', local_var_params['basicauthuser']))  # noqa: E501
        if 'basicauthpassword' in local_var_params and local_var_params['basicauthpassword'] is not None:  # noqa: E501
            query_params.append(('basicauthpassword', local_var_params['basicauthpassword']))  # noqa: E501
        if 'idempotency_key' in local_var_params and local_var_params['idempotency_key'] is not None:  # noqa: E501
            query_params.append(('idempotency_key', local_var_params['idempotency_key']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['basicAuth']  # noqa: E501

        return self.api_client.call_api(
            '/Keypads/{keypad-id}/Buttons/{button-id}/PushButton', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse2009',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def keypads_keypad_id_buttons_get(self, keypad_id, **kwargs):  # noqa: E501
        """Gets the buttons for a keypad  # noqa: E501

        Gets the buttons for the keypad specified by {keypad-id}.  If a keypad name is specified instead of a uuid, the buttons for the first keypad matching the specified name will be returned   # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.keypads_keypad_id_buttons_get(keypad_id, async_req=True)
        >>> result = thread.get()

        :param keypad_id: The keypad's name or unique identifier (uuid) (required)
        :type keypad_id: str
        :param basicauthuser: Username to use in place of username in basic authentication header.  For a secure installation, this value is ignored but still must be supplied unless a basic authentication header is sent with the request.
        :type basicauthuser: str
        :param basicauthpassword: Password to use in place of password in basic authentication header. For a secure installation, this should be an oauth token for a user with access to the installation.  If a basic authentication header is sent, this parameter is ignored.  If no basic authentication header is sent, this parameter as well as the basicauthuser parameter must be supplied if the hub is a member of a secure installation.
        :type basicauthpassword: str
        :param name: If specified, returns only the buttons matching the name provided
        :type name: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: InlineResponse20010
        """
        kwargs['_return_http_data_only'] = True
        return self.keypads_keypad_id_buttons_get_with_http_info(keypad_id, **kwargs)  # noqa: E501

    def keypads_keypad_id_buttons_get_with_http_info(self, keypad_id, **kwargs):  # noqa: E501
        """Gets the buttons for a keypad  # noqa: E501

        Gets the buttons for the keypad specified by {keypad-id}.  If a keypad name is specified instead of a uuid, the buttons for the first keypad matching the specified name will be returned   # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.keypads_keypad_id_buttons_get_with_http_info(keypad_id, async_req=True)
        >>> result = thread.get()

        :param keypad_id: The keypad's name or unique identifier (uuid) (required)
        :type keypad_id: str
        :param basicauthuser: Username to use in place of username in basic authentication header.  For a secure installation, this value is ignored but still must be supplied unless a basic authentication header is sent with the request.
        :type basicauthuser: str
        :param basicauthpassword: Password to use in place of password in basic authentication header. For a secure installation, this should be an oauth token for a user with access to the installation.  If a basic authentication header is sent, this parameter is ignored.  If no basic authentication header is sent, this parameter as well as the basicauthuser parameter must be supplied if the hub is a member of a secure installation.
        :type basicauthpassword: str
        :param name: If specified, returns only the buttons matching the name provided
        :type name: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(InlineResponse20010, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'keypad_id',
            'basicauthuser',
            'basicauthpassword',
            'name'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method keypads_keypad_id_buttons_get" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'keypad_id' is set
        if self.api_client.client_side_validation and ('keypad_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['keypad_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `keypad_id` when calling `keypads_keypad_id_buttons_get`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'keypad_id' in local_var_params:
            path_params['keypad-id'] = local_var_params['keypad_id']  # noqa: E501

        query_params = []
        if 'basicauthuser' in local_var_params and local_var_params['basicauthuser'] is not None:  # noqa: E501
            query_params.append(('basicauthuser', local_var_params['basicauthuser']))  # noqa: E501
        if 'basicauthpassword' in local_var_params and local_var_params['basicauthpassword'] is not None:  # noqa: E501
            query_params.append(('basicauthpassword', local_var_params['basicauthpassword']))  # noqa: E501
        if 'name' in local_var_params and local_var_params['name'] is not None:  # noqa: E501
            query_params.append(('name', local_var_params['name']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['basicAuth']  # noqa: E501

        return self.api_client.call_api(
            '/Keypads/{keypad-id}/Buttons', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse20010',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def keypads_keypad_id_get(self, keypad_id, **kwargs):  # noqa: E501
        """Gets a single keypad  # noqa: E501

        Gets a Ketra keypad speficied by {keypad-id}.  If a keypad name is specified instead of a uuid, the first keypad matching the specified name will be returned   # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.keypads_keypad_id_get(keypad_id, async_req=True)
        >>> result = thread.get()

        :param keypad_id: The keypad's name or unique identifier (uuid) (required)
        :type keypad_id: str
        :param basicauthuser: Username to use in place of username in basic authentication header.  For a secure installation, this value is ignored but still must be supplied unless a basic authentication header is sent with the request.
        :type basicauthuser: str
        :param basicauthpassword: Password to use in place of password in basic authentication header. For a secure installation, this should be an oauth token for a user with access to the installation.  If a basic authentication header is sent, this parameter is ignored.  If no basic authentication header is sent, this parameter as well as the basicauthuser parameter must be supplied if the hub is a member of a secure installation.
        :type basicauthpassword: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: InlineResponse2009
        """
        kwargs['_return_http_data_only'] = True
        return self.keypads_keypad_id_get_with_http_info(keypad_id, **kwargs)  # noqa: E501

    def keypads_keypad_id_get_with_http_info(self, keypad_id, **kwargs):  # noqa: E501
        """Gets a single keypad  # noqa: E501

        Gets a Ketra keypad speficied by {keypad-id}.  If a keypad name is specified instead of a uuid, the first keypad matching the specified name will be returned   # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.keypads_keypad_id_get_with_http_info(keypad_id, async_req=True)
        >>> result = thread.get()

        :param keypad_id: The keypad's name or unique identifier (uuid) (required)
        :type keypad_id: str
        :param basicauthuser: Username to use in place of username in basic authentication header.  For a secure installation, this value is ignored but still must be supplied unless a basic authentication header is sent with the request.
        :type basicauthuser: str
        :param basicauthpassword: Password to use in place of password in basic authentication header. For a secure installation, this should be an oauth token for a user with access to the installation.  If a basic authentication header is sent, this parameter is ignored.  If no basic authentication header is sent, this parameter as well as the basicauthuser parameter must be supplied if the hub is a member of a secure installation.
        :type basicauthpassword: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(InlineResponse2009, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'keypad_id',
            'basicauthuser',
            'basicauthpassword'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method keypads_keypad_id_get" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'keypad_id' is set
        if self.api_client.client_side_validation and ('keypad_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['keypad_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `keypad_id` when calling `keypads_keypad_id_get`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'keypad_id' in local_var_params:
            path_params['keypad-id'] = local_var_params['keypad_id']  # noqa: E501

        query_params = []
        if 'basicauthuser' in local_var_params and local_var_params['basicauthuser'] is not None:  # noqa: E501
            query_params.append(('basicauthuser', local_var_params['basicauthuser']))  # noqa: E501
        if 'basicauthpassword' in local_var_params and local_var_params['basicauthpassword'] is not None:  # noqa: E501
            query_params.append(('basicauthpassword', local_var_params['basicauthpassword']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['basicAuth']  # noqa: E501

        return self.api_client.call_api(
            '/Keypads/{keypad-id}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse2009',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def keypads_keypad_id_set_level_post(self, keypad_id, level, **kwargs):  # noqa: E501
        """sets the master intensity level for a single keypad  # noqa: E501

        Sets the keypad's intensity (brightness) slider to the level specified by the level parameter  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.keypads_keypad_id_set_level_post(keypad_id, level, async_req=True)
        >>> result = thread.get()

        :param keypad_id: The keypad's name or unique identifier (uuid) (required)
        :type keypad_id: str
        :param level: The level (required)
        :type level: bool
        :param basicauthuser: Username to use in place of username in basic authentication header.  For a secure installation, this value is ignored but still must be supplied unless a basic authentication header is sent with the request.
        :type basicauthuser: str
        :param basicauthpassword: Password to use in place of password in basic authentication header. For a secure installation, this should be an oauth token for a user with access to the installation.  If a basic authentication header is sent, this parameter is ignored.  If no basic authentication header is sent, this parameter as well as the basicauthuser parameter must be supplied if the hub is a member of a secure installation.
        :type basicauthpassword: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: InlineResponse2009
        """
        kwargs['_return_http_data_only'] = True
        return self.keypads_keypad_id_set_level_post_with_http_info(keypad_id, level, **kwargs)  # noqa: E501

    def keypads_keypad_id_set_level_post_with_http_info(self, keypad_id, level, **kwargs):  # noqa: E501
        """sets the master intensity level for a single keypad  # noqa: E501

        Sets the keypad's intensity (brightness) slider to the level specified by the level parameter  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.keypads_keypad_id_set_level_post_with_http_info(keypad_id, level, async_req=True)
        >>> result = thread.get()

        :param keypad_id: The keypad's name or unique identifier (uuid) (required)
        :type keypad_id: str
        :param level: The level (required)
        :type level: bool
        :param basicauthuser: Username to use in place of username in basic authentication header.  For a secure installation, this value is ignored but still must be supplied unless a basic authentication header is sent with the request.
        :type basicauthuser: str
        :param basicauthpassword: Password to use in place of password in basic authentication header. For a secure installation, this should be an oauth token for a user with access to the installation.  If a basic authentication header is sent, this parameter is ignored.  If no basic authentication header is sent, this parameter as well as the basicauthuser parameter must be supplied if the hub is a member of a secure installation.
        :type basicauthpassword: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(InlineResponse2009, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'keypad_id',
            'level',
            'basicauthuser',
            'basicauthpassword'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method keypads_keypad_id_set_level_post" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'keypad_id' is set
        if self.api_client.client_side_validation and ('keypad_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['keypad_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `keypad_id` when calling `keypads_keypad_id_set_level_post`")  # noqa: E501
        # verify the required parameter 'level' is set
        if self.api_client.client_side_validation and ('level' not in local_var_params or  # noqa: E501
                                                        local_var_params['level'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `level` when calling `keypads_keypad_id_set_level_post`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'keypad_id' in local_var_params:
            path_params['keypad-id'] = local_var_params['keypad_id']  # noqa: E501

        query_params = []
        if 'basicauthuser' in local_var_params and local_var_params['basicauthuser'] is not None:  # noqa: E501
            query_params.append(('basicauthuser', local_var_params['basicauthuser']))  # noqa: E501
        if 'basicauthpassword' in local_var_params and local_var_params['basicauthpassword'] is not None:  # noqa: E501
            query_params.append(('basicauthpassword', local_var_params['basicauthpassword']))  # noqa: E501
        if 'level' in local_var_params and local_var_params['level'] is not None:  # noqa: E501
            query_params.append(('Level', local_var_params['level']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['basicAuth']  # noqa: E501

        return self.api_client.call_api(
            '/Keypads/{keypad-id}/SetLevel', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse2009',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def push_button_post(self, keypad_name, button_name, **kwargs):  # noqa: E501
        """Deactivate a button  # noqa: E501

        Performs the same action as a physical press of the button.  The action performed is determined by the current state of the button and the type of keypad.   # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.push_button_post(keypad_name, button_name, async_req=True)
        >>> result = thread.get()

        :param keypad_name: Specifies a keypad name (required)
        :type keypad_name: str
        :param button_name: Specifies a button name (required)
        :type button_name: str
        :param basicauthuser: Username to use in place of username in basic authentication header.  For a secure installation, this value is ignored but still must be supplied unless a basic authentication header is sent with the request.
        :type basicauthuser: str
        :param basicauthpassword: Password to use in place of password in basic authentication header. For a secure installation, this should be an oauth token for a user with access to the installation.  If a basic authentication header is sent, this parameter is ignored.  If no basic authentication header is sent, this parameter as well as the basicauthuser parameter must be supplied if the hub is a member of a secure installation.
        :type basicauthpassword: str
        :param idempotency_key: optional string to guarantee this action will execute only once on the server.  Set this to a random string  and future requests with the same string will be ignored
        :type idempotency_key: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: InlineResponse2009
        """
        kwargs['_return_http_data_only'] = True
        return self.push_button_post_with_http_info(keypad_name, button_name, **kwargs)  # noqa: E501

    def push_button_post_with_http_info(self, keypad_name, button_name, **kwargs):  # noqa: E501
        """Deactivate a button  # noqa: E501

        Performs the same action as a physical press of the button.  The action performed is determined by the current state of the button and the type of keypad.   # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.push_button_post_with_http_info(keypad_name, button_name, async_req=True)
        >>> result = thread.get()

        :param keypad_name: Specifies a keypad name (required)
        :type keypad_name: str
        :param button_name: Specifies a button name (required)
        :type button_name: str
        :param basicauthuser: Username to use in place of username in basic authentication header.  For a secure installation, this value is ignored but still must be supplied unless a basic authentication header is sent with the request.
        :type basicauthuser: str
        :param basicauthpassword: Password to use in place of password in basic authentication header. For a secure installation, this should be an oauth token for a user with access to the installation.  If a basic authentication header is sent, this parameter is ignored.  If no basic authentication header is sent, this parameter as well as the basicauthuser parameter must be supplied if the hub is a member of a secure installation.
        :type basicauthpassword: str
        :param idempotency_key: optional string to guarantee this action will execute only once on the server.  Set this to a random string  and future requests with the same string will be ignored
        :type idempotency_key: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(InlineResponse2009, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'keypad_name',
            'button_name',
            'basicauthuser',
            'basicauthpassword',
            'idempotency_key'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method push_button_post" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'keypad_name' is set
        if self.api_client.client_side_validation and ('keypad_name' not in local_var_params or  # noqa: E501
                                                        local_var_params['keypad_name'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `keypad_name` when calling `push_button_post`")  # noqa: E501
        # verify the required parameter 'button_name' is set
        if self.api_client.client_side_validation and ('button_name' not in local_var_params or  # noqa: E501
                                                        local_var_params['button_name'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `button_name` when calling `push_button_post`")  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'basicauthuser' in local_var_params and local_var_params['basicauthuser'] is not None:  # noqa: E501
            query_params.append(('basicauthuser', local_var_params['basicauthuser']))  # noqa: E501
        if 'basicauthpassword' in local_var_params and local_var_params['basicauthpassword'] is not None:  # noqa: E501
            query_params.append(('basicauthpassword', local_var_params['basicauthpassword']))  # noqa: E501
        if 'keypad_name' in local_var_params and local_var_params['keypad_name'] is not None:  # noqa: E501
            query_params.append(('KeypadName', local_var_params['keypad_name']))  # noqa: E501
        if 'button_name' in local_var_params and local_var_params['button_name'] is not None:  # noqa: E501
            query_params.append(('ButtonName', local_var_params['button_name']))  # noqa: E501
        if 'idempotency_key' in local_var_params and local_var_params['idempotency_key'] is not None:  # noqa: E501
            query_params.append(('idempotency_key', local_var_params['idempotency_key']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['basicAuth']  # noqa: E501

        return self.api_client.call_api(
            '/PushButton', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse2009',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))

    def root_get(self, **kwargs):  # noqa: E501
        """Get keypads and groups  (and scenes in API schema 4 or later)  # noqa: E501

        Gets all keypads and groups in the installation.  Added in hub firmware version 1.14 (API schema 3).   Scenes are also returned in API schema 4.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.root_get(async_req=True)
        >>> result = thread.get()

        :param basicauthuser: Username to use in place of username in basic authentication header.  For a secure installation, this value is ignored but still must be supplied unless a basic authentication header is sent with the request.
        :type basicauthuser: str
        :param basicauthpassword: Password to use in place of password in basic authentication header. For a secure installation, this should be an oauth token for a user with access to the installation.  If a basic authentication header is sent, this parameter is ignored.  If no basic authentication header is sent, this parameter as well as the basicauthuser parameter must be supplied if the hub is a member of a secure installation.
        :type basicauthpassword: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: InlineResponse200
        """
        kwargs['_return_http_data_only'] = True
        return self.root_get_with_http_info(**kwargs)  # noqa: E501

    def root_get_with_http_info(self, **kwargs):  # noqa: E501
        """Get keypads and groups  (and scenes in API schema 4 or later)  # noqa: E501

        Gets all keypads and groups in the installation.  Added in hub firmware version 1.14 (API schema 3).   Scenes are also returned in API schema 4.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.root_get_with_http_info(async_req=True)
        >>> result = thread.get()

        :param basicauthuser: Username to use in place of username in basic authentication header.  For a secure installation, this value is ignored but still must be supplied unless a basic authentication header is sent with the request.
        :type basicauthuser: str
        :param basicauthpassword: Password to use in place of password in basic authentication header. For a secure installation, this should be an oauth token for a user with access to the installation.  If a basic authentication header is sent, this parameter is ignored.  If no basic authentication header is sent, this parameter as well as the basicauthuser parameter must be supplied if the hub is a member of a secure installation.
        :type basicauthpassword: str
        :param async_req: Whether to execute the request asynchronously.
        :type async_req: bool, optional
        :param _return_http_data_only: response data without head status code
                                       and headers
        :type _return_http_data_only: bool, optional
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :type _preload_content: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(InlineResponse200, status_code(int), headers(HTTPHeaderDict))
        """

        local_var_params = locals()

        all_params = [
            'basicauthuser',
            'basicauthpassword'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout',
                '_request_auth'
            ]
        )

        for key, val in six.iteritems(local_var_params['kwargs']):
            if key not in all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method root_get" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'basicauthuser' in local_var_params and local_var_params['basicauthuser'] is not None:  # noqa: E501
            query_params.append(('basicauthuser', local_var_params['basicauthuser']))  # noqa: E501
        if 'basicauthpassword' in local_var_params and local_var_params['basicauthpassword'] is not None:  # noqa: E501
            query_params.append(('basicauthpassword', local_var_params['basicauthpassword']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        # HTTP header `Accept`
        header_params['Accept'] = self.api_client.select_header_accept(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['basicAuth']  # noqa: E501

        return self.api_client.call_api(
            '/', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='InlineResponse200',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats,
            _request_auth=local_var_params.get('_request_auth'))
