"""
    SORACOM API

    SORACOM API v1  # noqa: E501

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


import re  # noqa: F401
import sys  # noqa: F401

from soracom_api.api_client import ApiClient, Endpoint as _Endpoint
from soracom_api.model_utils import (  # noqa: F401
    check_allowed_values,
    check_validations,
    date,
    datetime,
    file_type,
    none_type,
    validate_and_convert_types
)
from soracom_api.model.lora_gateway import LoraGateway
from soracom_api.model.set_network_set_request import SetNetworkSetRequest
from soracom_api.model.tag_update_request import TagUpdateRequest


class LoraGatewayApi(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
        self.delete_lora_gateway_tag_endpoint = _Endpoint(
            settings={
                'response_type': None,
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/lora_gateways/{gateway_id}/tags/{tag_name}',
                'operation_id': 'delete_lora_gateway_tag',
                'http_method': 'DELETE',
                'servers': None,
            },
            params_map={
                'all': [
                    'gateway_id',
                    'tag_name',
                ],
                'required': [
                    'gateway_id',
                    'tag_name',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'gateway_id':
                        (str,),
                    'tag_name':
                        (str,),
                },
                'attribute_map': {
                    'gateway_id': 'gateway_id',
                    'tag_name': 'tag_name',
                },
                'location_map': {
                    'gateway_id': 'path',
                    'tag_name': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [],
                'content_type': [],
            },
            api_client=api_client
        )
        self.disable_termination_on_lora_gateway_endpoint = _Endpoint(
            settings={
                'response_type': (LoraGateway,),
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/lora_gateways/{gateway_id}/disable_termination',
                'operation_id': 'disable_termination_on_lora_gateway',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'gateway_id',
                ],
                'required': [
                    'gateway_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'gateway_id':
                        (str,),
                },
                'attribute_map': {
                    'gateway_id': 'gateway_id',
                },
                'location_map': {
                    'gateway_id': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.enable_termination_on_lora_gateway_endpoint = _Endpoint(
            settings={
                'response_type': (LoraGateway,),
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/lora_gateways/{gateway_id}/enable_termination',
                'operation_id': 'enable_termination_on_lora_gateway',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'gateway_id',
                ],
                'required': [
                    'gateway_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'gateway_id':
                        (str,),
                },
                'attribute_map': {
                    'gateway_id': 'gateway_id',
                },
                'location_map': {
                    'gateway_id': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_lora_gateway_endpoint = _Endpoint(
            settings={
                'response_type': (LoraGateway,),
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/lora_gateways/{gateway_id}',
                'operation_id': 'get_lora_gateway',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'gateway_id',
                ],
                'required': [
                    'gateway_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'gateway_id':
                        (str,),
                },
                'attribute_map': {
                    'gateway_id': 'gateway_id',
                },
                'location_map': {
                    'gateway_id': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.list_lora_gateways_endpoint = _Endpoint(
            settings={
                'response_type': ([LoraGateway],),
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/lora_gateways',
                'operation_id': 'list_lora_gateways',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'tag_name',
                    'tag_value',
                    'tag_value_match_mode',
                    'limit',
                    'last_evaluated_key',
                ],
                'required': [],
                'nullable': [
                ],
                'enum': [
                    'tag_value_match_mode',
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                    ('tag_value_match_mode',): {

                        "EXACT": "exact",
                        "PREFIX": "prefix"
                    },
                },
                'openapi_types': {
                    'tag_name':
                        (str,),
                    'tag_value':
                        (str,),
                    'tag_value_match_mode':
                        (str,),
                    'limit':
                        (int,),
                    'last_evaluated_key':
                        (str,),
                },
                'attribute_map': {
                    'tag_name': 'tag_name',
                    'tag_value': 'tag_value',
                    'tag_value_match_mode': 'tag_value_match_mode',
                    'limit': 'limit',
                    'last_evaluated_key': 'last_evaluated_key',
                },
                'location_map': {
                    'tag_name': 'query',
                    'tag_value': 'query',
                    'tag_value_match_mode': 'query',
                    'limit': 'query',
                    'last_evaluated_key': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.put_lora_gateway_tags_endpoint = _Endpoint(
            settings={
                'response_type': (LoraGateway,),
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/lora_gateways/{gateway_id}/tags',
                'operation_id': 'put_lora_gateway_tags',
                'http_method': 'PUT',
                'servers': None,
            },
            params_map={
                'all': [
                    'gateway_id',
                    'tag_update_request',
                ],
                'required': [
                    'gateway_id',
                    'tag_update_request',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'gateway_id':
                        (str,),
                    'tag_update_request':
                        ([TagUpdateRequest],),
                },
                'attribute_map': {
                    'gateway_id': 'gateway_id',
                },
                'location_map': {
                    'gateway_id': 'path',
                    'tag_update_request': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.set_lora_network_set_endpoint = _Endpoint(
            settings={
                'response_type': (LoraGateway,),
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/lora_gateways/{gateway_id}/set_network_set',
                'operation_id': 'set_lora_network_set',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'gateway_id',
                    'set_network_set_request',
                ],
                'required': [
                    'gateway_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'gateway_id':
                        (str,),
                    'set_network_set_request':
                        (SetNetworkSetRequest,),
                },
                'attribute_map': {
                    'gateway_id': 'gateway_id',
                },
                'location_map': {
                    'gateway_id': 'path',
                    'set_network_set_request': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'text/plain'
                ]
            },
            api_client=api_client
        )
        self.terminate_lora_gateway_endpoint = _Endpoint(
            settings={
                'response_type': (LoraGateway,),
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/lora_gateways/{gateway_id}/terminate',
                'operation_id': 'terminate_lora_gateway',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'gateway_id',
                ],
                'required': [
                    'gateway_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'gateway_id':
                        (str,),
                },
                'attribute_map': {
                    'gateway_id': 'gateway_id',
                },
                'location_map': {
                    'gateway_id': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.unset_lora_network_set_endpoint = _Endpoint(
            settings={
                'response_type': (LoraGateway,),
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/lora_gateways/{gateway_id}/unset_network_set',
                'operation_id': 'unset_lora_network_set',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'gateway_id',
                ],
                'required': [
                    'gateway_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'gateway_id':
                        (str,),
                },
                'attribute_map': {
                    'gateway_id': 'gateway_id',
                },
                'location_map': {
                    'gateway_id': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )

    def delete_lora_gateway_tag(
        self,
        gateway_id,
        tag_name,
        **kwargs
    ):
        """Delete LoRa gateway tag.  # noqa: E501

        Deletes a tag from the specified LoRa gateway.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.delete_lora_gateway_tag(gateway_id, tag_name, async_req=True)
        >>> result = thread.get()

        Args:
            gateway_id (str): ID of the target LoRa gateway.
            tag_name (str): Name of tag to be deleted. (This will be part of a URL path, so it needs to be percent-encoded. In JavaScript, specify the name after it has been encoded using encodeURIComponent().)

        Keyword Args:
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/float/tuple): 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.
                Default is None.
            _check_input_type (bool): specifies if type checking
                should be done one the data sent to the server.
                Default is True.
            _check_return_type (bool): specifies if type checking
                should be done one the data received from the server.
                Default is True.
            _spec_property_naming (bool): True if the variable names in the input data
                are serialized names, as specified in the OpenAPI document.
                False if the variable names in the input data
                are pythonic names, e.g. snake case (default)
            _content_type (str/None): force body content-type.
                Default is None and content-type will be predicted by allowed
                content-types and body.
            _host_index (int/None): specifies the index of the server
                that we want to use.
                Default is read from the configuration.
            async_req (bool): execute request asynchronously

        Returns:
            None
                If the method is called asynchronously, returns the request
                thread.
        """
        kwargs['async_req'] = kwargs.get(
            'async_req', False
        )
        kwargs['_return_http_data_only'] = kwargs.get(
            '_return_http_data_only', True
        )
        kwargs['_preload_content'] = kwargs.get(
            '_preload_content', True
        )
        kwargs['_request_timeout'] = kwargs.get(
            '_request_timeout', None
        )
        kwargs['_check_input_type'] = kwargs.get(
            '_check_input_type', True
        )
        kwargs['_check_return_type'] = kwargs.get(
            '_check_return_type', True
        )
        kwargs['_spec_property_naming'] = kwargs.get(
            '_spec_property_naming', False
        )
        kwargs['_content_type'] = kwargs.get(
            '_content_type')
        kwargs['_host_index'] = kwargs.get('_host_index')
        kwargs['gateway_id'] = \
            gateway_id
        kwargs['tag_name'] = \
            tag_name
        return self.delete_lora_gateway_tag_endpoint.call_with_http_info(**kwargs)

    def disable_termination_on_lora_gateway(
        self,
        gateway_id,
        **kwargs
    ):
        """Disable Termination of LoRa gateway.  # noqa: E501

        Disables termination of specified LoRa gateway.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.disable_termination_on_lora_gateway(gateway_id, async_req=True)
        >>> result = thread.get()

        Args:
            gateway_id (str): ID of the target LoRa gateway.

        Keyword Args:
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/float/tuple): 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.
                Default is None.
            _check_input_type (bool): specifies if type checking
                should be done one the data sent to the server.
                Default is True.
            _check_return_type (bool): specifies if type checking
                should be done one the data received from the server.
                Default is True.
            _spec_property_naming (bool): True if the variable names in the input data
                are serialized names, as specified in the OpenAPI document.
                False if the variable names in the input data
                are pythonic names, e.g. snake case (default)
            _content_type (str/None): force body content-type.
                Default is None and content-type will be predicted by allowed
                content-types and body.
            _host_index (int/None): specifies the index of the server
                that we want to use.
                Default is read from the configuration.
            async_req (bool): execute request asynchronously

        Returns:
            LoraGateway
                If the method is called asynchronously, returns the request
                thread.
        """
        kwargs['async_req'] = kwargs.get(
            'async_req', False
        )
        kwargs['_return_http_data_only'] = kwargs.get(
            '_return_http_data_only', True
        )
        kwargs['_preload_content'] = kwargs.get(
            '_preload_content', True
        )
        kwargs['_request_timeout'] = kwargs.get(
            '_request_timeout', None
        )
        kwargs['_check_input_type'] = kwargs.get(
            '_check_input_type', True
        )
        kwargs['_check_return_type'] = kwargs.get(
            '_check_return_type', True
        )
        kwargs['_spec_property_naming'] = kwargs.get(
            '_spec_property_naming', False
        )
        kwargs['_content_type'] = kwargs.get(
            '_content_type')
        kwargs['_host_index'] = kwargs.get('_host_index')
        kwargs['gateway_id'] = \
            gateway_id
        return self.disable_termination_on_lora_gateway_endpoint.call_with_http_info(**kwargs)

    def enable_termination_on_lora_gateway(
        self,
        gateway_id,
        **kwargs
    ):
        """Enable Termination of LoRa gateway.  # noqa: E501

        Enables termination of specified LoRa gateway.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.enable_termination_on_lora_gateway(gateway_id, async_req=True)
        >>> result = thread.get()

        Args:
            gateway_id (str): ID of the target LoRa gateway.

        Keyword Args:
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/float/tuple): 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.
                Default is None.
            _check_input_type (bool): specifies if type checking
                should be done one the data sent to the server.
                Default is True.
            _check_return_type (bool): specifies if type checking
                should be done one the data received from the server.
                Default is True.
            _spec_property_naming (bool): True if the variable names in the input data
                are serialized names, as specified in the OpenAPI document.
                False if the variable names in the input data
                are pythonic names, e.g. snake case (default)
            _content_type (str/None): force body content-type.
                Default is None and content-type will be predicted by allowed
                content-types and body.
            _host_index (int/None): specifies the index of the server
                that we want to use.
                Default is read from the configuration.
            async_req (bool): execute request asynchronously

        Returns:
            LoraGateway
                If the method is called asynchronously, returns the request
                thread.
        """
        kwargs['async_req'] = kwargs.get(
            'async_req', False
        )
        kwargs['_return_http_data_only'] = kwargs.get(
            '_return_http_data_only', True
        )
        kwargs['_preload_content'] = kwargs.get(
            '_preload_content', True
        )
        kwargs['_request_timeout'] = kwargs.get(
            '_request_timeout', None
        )
        kwargs['_check_input_type'] = kwargs.get(
            '_check_input_type', True
        )
        kwargs['_check_return_type'] = kwargs.get(
            '_check_return_type', True
        )
        kwargs['_spec_property_naming'] = kwargs.get(
            '_spec_property_naming', False
        )
        kwargs['_content_type'] = kwargs.get(
            '_content_type')
        kwargs['_host_index'] = kwargs.get('_host_index')
        kwargs['gateway_id'] = \
            gateway_id
        return self.enable_termination_on_lora_gateway_endpoint.call_with_http_info(**kwargs)

    def get_lora_gateway(
        self,
        gateway_id,
        **kwargs
    ):
        """Get LoRa gateway.  # noqa: E501

        Returns information about the specified LoRa gateway.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.get_lora_gateway(gateway_id, async_req=True)
        >>> result = thread.get()

        Args:
            gateway_id (str): Gateway ID of the target LoRa gateway.

        Keyword Args:
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/float/tuple): 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.
                Default is None.
            _check_input_type (bool): specifies if type checking
                should be done one the data sent to the server.
                Default is True.
            _check_return_type (bool): specifies if type checking
                should be done one the data received from the server.
                Default is True.
            _spec_property_naming (bool): True if the variable names in the input data
                are serialized names, as specified in the OpenAPI document.
                False if the variable names in the input data
                are pythonic names, e.g. snake case (default)
            _content_type (str/None): force body content-type.
                Default is None and content-type will be predicted by allowed
                content-types and body.
            _host_index (int/None): specifies the index of the server
                that we want to use.
                Default is read from the configuration.
            async_req (bool): execute request asynchronously

        Returns:
            LoraGateway
                If the method is called asynchronously, returns the request
                thread.
        """
        kwargs['async_req'] = kwargs.get(
            'async_req', False
        )
        kwargs['_return_http_data_only'] = kwargs.get(
            '_return_http_data_only', True
        )
        kwargs['_preload_content'] = kwargs.get(
            '_preload_content', True
        )
        kwargs['_request_timeout'] = kwargs.get(
            '_request_timeout', None
        )
        kwargs['_check_input_type'] = kwargs.get(
            '_check_input_type', True
        )
        kwargs['_check_return_type'] = kwargs.get(
            '_check_return_type', True
        )
        kwargs['_spec_property_naming'] = kwargs.get(
            '_spec_property_naming', False
        )
        kwargs['_content_type'] = kwargs.get(
            '_content_type')
        kwargs['_host_index'] = kwargs.get('_host_index')
        kwargs['gateway_id'] = \
            gateway_id
        return self.get_lora_gateway_endpoint.call_with_http_info(**kwargs)

    def list_lora_gateways(
        self,
        **kwargs
    ):
        """List LoRa Gateways.  # noqa: E501

        Returns a list of LoRa gateways that match certain criteria. If the total number of LoRa gateways does not fit in one page, a URL for accessing the next page is returned in the 'Link' header of the response.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

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


        Keyword Args:
            tag_name (str): Tag name for filtering the search (exact match).. [optional]
            tag_value (str): Tag search string for filtering the search. Required when `tag_name` has been specified.. [optional]
            tag_value_match_mode (str): Tag match mode.. [optional] if omitted the server will use the default value of "exact"
            limit (int): Maximum number of LoRa devices to retrieve.. [optional]
            last_evaluated_key (str): The device ID of the last device retrieved on the current page. By specifying this parameter, you can continue to retrieve the list from the next device onward.. [optional]
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/float/tuple): 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.
                Default is None.
            _check_input_type (bool): specifies if type checking
                should be done one the data sent to the server.
                Default is True.
            _check_return_type (bool): specifies if type checking
                should be done one the data received from the server.
                Default is True.
            _spec_property_naming (bool): True if the variable names in the input data
                are serialized names, as specified in the OpenAPI document.
                False if the variable names in the input data
                are pythonic names, e.g. snake case (default)
            _content_type (str/None): force body content-type.
                Default is None and content-type will be predicted by allowed
                content-types and body.
            _host_index (int/None): specifies the index of the server
                that we want to use.
                Default is read from the configuration.
            async_req (bool): execute request asynchronously

        Returns:
            [LoraGateway]
                If the method is called asynchronously, returns the request
                thread.
        """
        kwargs['async_req'] = kwargs.get(
            'async_req', False
        )
        kwargs['_return_http_data_only'] = kwargs.get(
            '_return_http_data_only', True
        )
        kwargs['_preload_content'] = kwargs.get(
            '_preload_content', True
        )
        kwargs['_request_timeout'] = kwargs.get(
            '_request_timeout', None
        )
        kwargs['_check_input_type'] = kwargs.get(
            '_check_input_type', True
        )
        kwargs['_check_return_type'] = kwargs.get(
            '_check_return_type', True
        )
        kwargs['_spec_property_naming'] = kwargs.get(
            '_spec_property_naming', False
        )
        kwargs['_content_type'] = kwargs.get(
            '_content_type')
        kwargs['_host_index'] = kwargs.get('_host_index')
        return self.list_lora_gateways_endpoint.call_with_http_info(**kwargs)

    def put_lora_gateway_tags(
        self,
        gateway_id,
        tag_update_request,
        **kwargs
    ):
        """Bulk Insert or Update LoRa gateway Tags.  # noqa: E501

        Inserts/updates tags for the specified LoRa gateway.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.put_lora_gateway_tags(gateway_id, tag_update_request, async_req=True)
        >>> result = thread.get()

        Args:
            gateway_id (str): ID of the target LoRa gateway.
            tag_update_request ([TagUpdateRequest]): Array of tags to be inserted/updated.

        Keyword Args:
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/float/tuple): 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.
                Default is None.
            _check_input_type (bool): specifies if type checking
                should be done one the data sent to the server.
                Default is True.
            _check_return_type (bool): specifies if type checking
                should be done one the data received from the server.
                Default is True.
            _spec_property_naming (bool): True if the variable names in the input data
                are serialized names, as specified in the OpenAPI document.
                False if the variable names in the input data
                are pythonic names, e.g. snake case (default)
            _content_type (str/None): force body content-type.
                Default is None and content-type will be predicted by allowed
                content-types and body.
            _host_index (int/None): specifies the index of the server
                that we want to use.
                Default is read from the configuration.
            async_req (bool): execute request asynchronously

        Returns:
            LoraGateway
                If the method is called asynchronously, returns the request
                thread.
        """
        kwargs['async_req'] = kwargs.get(
            'async_req', False
        )
        kwargs['_return_http_data_only'] = kwargs.get(
            '_return_http_data_only', True
        )
        kwargs['_preload_content'] = kwargs.get(
            '_preload_content', True
        )
        kwargs['_request_timeout'] = kwargs.get(
            '_request_timeout', None
        )
        kwargs['_check_input_type'] = kwargs.get(
            '_check_input_type', True
        )
        kwargs['_check_return_type'] = kwargs.get(
            '_check_return_type', True
        )
        kwargs['_spec_property_naming'] = kwargs.get(
            '_spec_property_naming', False
        )
        kwargs['_content_type'] = kwargs.get(
            '_content_type')
        kwargs['_host_index'] = kwargs.get('_host_index')
        kwargs['gateway_id'] = \
            gateway_id
        kwargs['tag_update_request'] = \
            tag_update_request
        return self.put_lora_gateway_tags_endpoint.call_with_http_info(**kwargs)

    def set_lora_network_set(
        self,
        gateway_id,
        **kwargs
    ):
        """Set Network Set ID of LoRa gateway.  # noqa: E501

        Sets or overwrites network set ID for the specified LoRa gateway.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.set_lora_network_set(gateway_id, async_req=True)
        >>> result = thread.get()

        Args:
            gateway_id (str): ID of the target LoRa gateway.

        Keyword Args:
            set_network_set_request (SetNetworkSetRequest): LoRa Network Set ID.. [optional]
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/float/tuple): 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.
                Default is None.
            _check_input_type (bool): specifies if type checking
                should be done one the data sent to the server.
                Default is True.
            _check_return_type (bool): specifies if type checking
                should be done one the data received from the server.
                Default is True.
            _spec_property_naming (bool): True if the variable names in the input data
                are serialized names, as specified in the OpenAPI document.
                False if the variable names in the input data
                are pythonic names, e.g. snake case (default)
            _content_type (str/None): force body content-type.
                Default is None and content-type will be predicted by allowed
                content-types and body.
            _host_index (int/None): specifies the index of the server
                that we want to use.
                Default is read from the configuration.
            async_req (bool): execute request asynchronously

        Returns:
            LoraGateway
                If the method is called asynchronously, returns the request
                thread.
        """
        kwargs['async_req'] = kwargs.get(
            'async_req', False
        )
        kwargs['_return_http_data_only'] = kwargs.get(
            '_return_http_data_only', True
        )
        kwargs['_preload_content'] = kwargs.get(
            '_preload_content', True
        )
        kwargs['_request_timeout'] = kwargs.get(
            '_request_timeout', None
        )
        kwargs['_check_input_type'] = kwargs.get(
            '_check_input_type', True
        )
        kwargs['_check_return_type'] = kwargs.get(
            '_check_return_type', True
        )
        kwargs['_spec_property_naming'] = kwargs.get(
            '_spec_property_naming', False
        )
        kwargs['_content_type'] = kwargs.get(
            '_content_type')
        kwargs['_host_index'] = kwargs.get('_host_index')
        kwargs['gateway_id'] = \
            gateway_id
        return self.set_lora_network_set_endpoint.call_with_http_info(**kwargs)

    def terminate_lora_gateway(
        self,
        gateway_id,
        **kwargs
    ):
        """Terminate LoRa gateway.  # noqa: E501

        Terminates the specified LoRa gateway  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.terminate_lora_gateway(gateway_id, async_req=True)
        >>> result = thread.get()

        Args:
            gateway_id (str): Device ID of the target LoRa gateway.

        Keyword Args:
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/float/tuple): 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.
                Default is None.
            _check_input_type (bool): specifies if type checking
                should be done one the data sent to the server.
                Default is True.
            _check_return_type (bool): specifies if type checking
                should be done one the data received from the server.
                Default is True.
            _spec_property_naming (bool): True if the variable names in the input data
                are serialized names, as specified in the OpenAPI document.
                False if the variable names in the input data
                are pythonic names, e.g. snake case (default)
            _content_type (str/None): force body content-type.
                Default is None and content-type will be predicted by allowed
                content-types and body.
            _host_index (int/None): specifies the index of the server
                that we want to use.
                Default is read from the configuration.
            async_req (bool): execute request asynchronously

        Returns:
            LoraGateway
                If the method is called asynchronously, returns the request
                thread.
        """
        kwargs['async_req'] = kwargs.get(
            'async_req', False
        )
        kwargs['_return_http_data_only'] = kwargs.get(
            '_return_http_data_only', True
        )
        kwargs['_preload_content'] = kwargs.get(
            '_preload_content', True
        )
        kwargs['_request_timeout'] = kwargs.get(
            '_request_timeout', None
        )
        kwargs['_check_input_type'] = kwargs.get(
            '_check_input_type', True
        )
        kwargs['_check_return_type'] = kwargs.get(
            '_check_return_type', True
        )
        kwargs['_spec_property_naming'] = kwargs.get(
            '_spec_property_naming', False
        )
        kwargs['_content_type'] = kwargs.get(
            '_content_type')
        kwargs['_host_index'] = kwargs.get('_host_index')
        kwargs['gateway_id'] = \
            gateway_id
        return self.terminate_lora_gateway_endpoint.call_with_http_info(**kwargs)

    def unset_lora_network_set(
        self,
        gateway_id,
        **kwargs
    ):
        """Unset Network Set ID of LoRa gateway.  # noqa: E501

        Unset network set ID of the specified LoRa gateway.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.unset_lora_network_set(gateway_id, async_req=True)
        >>> result = thread.get()

        Args:
            gateway_id (str): ID of the target LoRa gateway.

        Keyword Args:
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/float/tuple): 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.
                Default is None.
            _check_input_type (bool): specifies if type checking
                should be done one the data sent to the server.
                Default is True.
            _check_return_type (bool): specifies if type checking
                should be done one the data received from the server.
                Default is True.
            _spec_property_naming (bool): True if the variable names in the input data
                are serialized names, as specified in the OpenAPI document.
                False if the variable names in the input data
                are pythonic names, e.g. snake case (default)
            _content_type (str/None): force body content-type.
                Default is None and content-type will be predicted by allowed
                content-types and body.
            _host_index (int/None): specifies the index of the server
                that we want to use.
                Default is read from the configuration.
            async_req (bool): execute request asynchronously

        Returns:
            LoraGateway
                If the method is called asynchronously, returns the request
                thread.
        """
        kwargs['async_req'] = kwargs.get(
            'async_req', False
        )
        kwargs['_return_http_data_only'] = kwargs.get(
            '_return_http_data_only', True
        )
        kwargs['_preload_content'] = kwargs.get(
            '_preload_content', True
        )
        kwargs['_request_timeout'] = kwargs.get(
            '_request_timeout', None
        )
        kwargs['_check_input_type'] = kwargs.get(
            '_check_input_type', True
        )
        kwargs['_check_return_type'] = kwargs.get(
            '_check_return_type', True
        )
        kwargs['_spec_property_naming'] = kwargs.get(
            '_spec_property_naming', False
        )
        kwargs['_content_type'] = kwargs.get(
            '_content_type')
        kwargs['_host_index'] = kwargs.get('_host_index')
        kwargs['gateway_id'] = \
            gateway_id
        return self.unset_lora_network_set_endpoint.call_with_http_info(**kwargs)

