"""
    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.lagoon_dashboard_permissions_response import LagoonDashboardPermissionsResponse
from soracom_api.model.lagoon_dashboard_permissions_updating_request import LagoonDashboardPermissionsUpdatingRequest
from soracom_api.model.lagoon_license_pack_status_response import LagoonLicensePackStatusResponse
from soracom_api.model.lagoon_license_packs_updating_request import LagoonLicensePacksUpdatingRequest
from soracom_api.model.lagoon_migration_from_classic_request import LagoonMigrationFromClassicRequest
from soracom_api.model.lagoon_plan_changing_request import LagoonPlanChangingRequest
from soracom_api.model.lagoon_registration_request import LagoonRegistrationRequest
from soracom_api.model.lagoon_registration_response import LagoonRegistrationResponse
from soracom_api.model.lagoon_user import LagoonUser
from soracom_api.model.lagoon_user_creation_request import LagoonUserCreationRequest
from soracom_api.model.lagoon_user_creation_response import LagoonUserCreationResponse
from soracom_api.model.lagoon_user_email_updating_request import LagoonUserEmailUpdatingRequest
from soracom_api.model.lagoon_user_password_updating_request import LagoonUserPasswordUpdatingRequest
from soracom_api.model.lagoon_user_permission_updating_request import LagoonUserPermissionUpdatingRequest


class LagoonApi(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.create_lagoon_user_endpoint = _Endpoint(
            settings={
                'response_type': (LagoonUserCreationResponse,),
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/lagoon/users',
                'operation_id': 'create_lagoon_user',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'lagoon_user_creation_request',
                ],
                'required': [
                    'lagoon_user_creation_request',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'lagoon_user_creation_request':
                        (LagoonUserCreationRequest,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'lagoon_user_creation_request': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.delete_lagoon_user_endpoint = _Endpoint(
            settings={
                'response_type': None,
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/lagoon/users/{lagoon_user_id}',
                'operation_id': 'delete_lagoon_user',
                'http_method': 'DELETE',
                'servers': None,
            },
            params_map={
                'all': [
                    'lagoon_user_id',
                ],
                'required': [
                    'lagoon_user_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'lagoon_user_id':
                        (int,),
                },
                'attribute_map': {
                    'lagoon_user_id': 'lagoon_user_id',
                },
                'location_map': {
                    'lagoon_user_id': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_image_link_endpoint = _Endpoint(
            settings={
                'response_type': (str,),
                'auth': [],
                'endpoint_path': '/lagoon/image/link',
                'operation_id': 'get_image_link',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'classic',
                ],
                'required': [],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'classic':
                        (bool,),
                },
                'attribute_map': {
                    'classic': 'classic',
                },
                'location_map': {
                    'classic': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_lagoon_migration_info_endpoint = _Endpoint(
            settings={
                'response_type': None,
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/lagoon/migration',
                'operation_id': 'get_lagoon_migration_info',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'lagoon_plan_changing_request',
                ],
                'required': [
                    'lagoon_plan_changing_request',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'lagoon_plan_changing_request':
                        (LagoonPlanChangingRequest,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'lagoon_plan_changing_request': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.initialize_lagoon_dashboard_permissions_endpoint = _Endpoint(
            settings={
                'response_type': None,
                'auth': [],
                'endpoint_path': '/lagoon/dashboards/{dashboard_id}/permissions/init',
                'operation_id': 'initialize_lagoon_dashboard_permissions',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'dashboard_id',
                    'classic',
                ],
                'required': [
                    'dashboard_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'dashboard_id':
                        (int,),
                    'classic':
                        (bool,),
                },
                'attribute_map': {
                    'dashboard_id': 'dashboard_id',
                    'classic': 'classic',
                },
                'location_map': {
                    'dashboard_id': 'path',
                    'classic': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [],
                'content_type': [],
            },
            api_client=api_client
        )
        self.list_lagoon_dashboards_permissions_endpoint = _Endpoint(
            settings={
                'response_type': ([LagoonDashboardPermissionsResponse],),
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/lagoon/dashboards/permissions',
                'operation_id': 'list_lagoon_dashboards_permissions',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'classic',
                ],
                'required': [],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'classic':
                        (bool,),
                },
                'attribute_map': {
                    'classic': 'classic',
                },
                'location_map': {
                    'classic': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.list_lagoon_license_pack_status_endpoint = _Endpoint(
            settings={
                'response_type': ([LagoonLicensePackStatusResponse],),
                'auth': [],
                'endpoint_path': '/lagoon/license_packs',
                'operation_id': 'list_lagoon_license_pack_status',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                ],
                'required': [],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                },
                'attribute_map': {
                },
                'location_map': {
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.list_lagoon_users_endpoint = _Endpoint(
            settings={
                'response_type': ([LagoonUser],),
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/lagoon/users',
                'operation_id': 'list_lagoon_users',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'classic',
                ],
                'required': [],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'classic':
                        (bool,),
                },
                'attribute_map': {
                    'classic': 'classic',
                },
                'location_map': {
                    'classic': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.migrate_lagoon_endpoint = _Endpoint(
            settings={
                'response_type': None,
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/lagoon/migration',
                'operation_id': 'migrate_lagoon',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'lagoon_migration_from_classic_request',
                ],
                'required': [
                    'lagoon_migration_from_classic_request',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'lagoon_migration_from_classic_request':
                        (LagoonMigrationFromClassicRequest,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'lagoon_migration_from_classic_request': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.register_lagoon_endpoint = _Endpoint(
            settings={
                'response_type': (LagoonRegistrationResponse,),
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/lagoon/register',
                'operation_id': 'register_lagoon',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'lagoon_registration_request',
                ],
                'required': [
                    'lagoon_registration_request',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'lagoon_registration_request':
                        (LagoonRegistrationRequest,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'lagoon_registration_request': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.terminate_lagoon_endpoint = _Endpoint(
            settings={
                'response_type': None,
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/lagoon/terminate',
                'operation_id': 'terminate_lagoon',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                ],
                'required': [],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                },
                'attribute_map': {
                },
                'location_map': {
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [],
                'content_type': [],
            },
            api_client=api_client
        )
        self.update_lagoon_dashboard_permissions_endpoint = _Endpoint(
            settings={
                'response_type': None,
                'auth': [],
                'endpoint_path': '/lagoon/dashboards/{dashboard_id}/permissions',
                'operation_id': 'update_lagoon_dashboard_permissions',
                'http_method': 'PUT',
                'servers': None,
            },
            params_map={
                'all': [
                    'dashboard_id',
                    'lagoon_dashboard_permissions_updating_request',
                    'classic',
                ],
                'required': [
                    'dashboard_id',
                    'lagoon_dashboard_permissions_updating_request',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'dashboard_id':
                        (int,),
                    'lagoon_dashboard_permissions_updating_request':
                        (LagoonDashboardPermissionsUpdatingRequest,),
                    'classic':
                        (bool,),
                },
                'attribute_map': {
                    'dashboard_id': 'dashboard_id',
                    'classic': 'classic',
                },
                'location_map': {
                    'dashboard_id': 'path',
                    'lagoon_dashboard_permissions_updating_request': 'body',
                    'classic': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.update_lagoon_license_pack_endpoint = _Endpoint(
            settings={
                'response_type': None,
                'auth': [],
                'endpoint_path': '/lagoon/license_packs',
                'operation_id': 'update_lagoon_license_pack',
                'http_method': 'PUT',
                'servers': None,
            },
            params_map={
                'all': [
                    'lagoon_license_packs_updating_request',
                ],
                'required': [
                    'lagoon_license_packs_updating_request',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'lagoon_license_packs_updating_request':
                        (LagoonLicensePacksUpdatingRequest,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'lagoon_license_packs_updating_request': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.update_lagoon_plan_endpoint = _Endpoint(
            settings={
                'response_type': None,
                'auth': [],
                'endpoint_path': '/lagoon/plan',
                'operation_id': 'update_lagoon_plan',
                'http_method': 'PUT',
                'servers': None,
            },
            params_map={
                'all': [
                    'lagoon_plan_changing_request',
                ],
                'required': [
                    'lagoon_plan_changing_request',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'lagoon_plan_changing_request':
                        (LagoonPlanChangingRequest,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'lagoon_plan_changing_request': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.update_lagoon_user_email_endpoint = _Endpoint(
            settings={
                'response_type': None,
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/lagoon/users/{lagoon_user_id}/email',
                'operation_id': 'update_lagoon_user_email',
                'http_method': 'PUT',
                'servers': None,
            },
            params_map={
                'all': [
                    'lagoon_user_id',
                    'lagoon_user_email_updating_request',
                ],
                'required': [
                    'lagoon_user_id',
                    'lagoon_user_email_updating_request',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'lagoon_user_id':
                        (int,),
                    'lagoon_user_email_updating_request':
                        (LagoonUserEmailUpdatingRequest,),
                },
                'attribute_map': {
                    'lagoon_user_id': 'lagoon_user_id',
                },
                'location_map': {
                    'lagoon_user_id': 'path',
                    'lagoon_user_email_updating_request': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.update_lagoon_user_password_endpoint = _Endpoint(
            settings={
                'response_type': None,
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/lagoon/users/{lagoon_user_id}/password',
                'operation_id': 'update_lagoon_user_password',
                'http_method': 'PUT',
                'servers': None,
            },
            params_map={
                'all': [
                    'lagoon_user_id',
                    'lagoon_user_password_updating_request',
                ],
                'required': [
                    'lagoon_user_id',
                    'lagoon_user_password_updating_request',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'lagoon_user_id':
                        (int,),
                    'lagoon_user_password_updating_request':
                        (LagoonUserPasswordUpdatingRequest,),
                },
                'attribute_map': {
                    'lagoon_user_id': 'lagoon_user_id',
                },
                'location_map': {
                    'lagoon_user_id': 'path',
                    'lagoon_user_password_updating_request': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.update_lagoon_user_permission_endpoint = _Endpoint(
            settings={
                'response_type': None,
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/lagoon/users/{lagoon_user_id}/permission',
                'operation_id': 'update_lagoon_user_permission',
                'http_method': 'PUT',
                'servers': None,
            },
            params_map={
                'all': [
                    'lagoon_user_id',
                    'lagoon_user_permission_updating_request',
                ],
                'required': [
                    'lagoon_user_id',
                    'lagoon_user_permission_updating_request',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'lagoon_user_id':
                        (int,),
                    'lagoon_user_permission_updating_request':
                        (LagoonUserPermissionUpdatingRequest,),
                },
                'attribute_map': {
                    'lagoon_user_id': 'lagoon_user_id',
                },
                'location_map': {
                    'lagoon_user_id': 'path',
                    'lagoon_user_permission_updating_request': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )

    def create_lagoon_user(
        self,
        lagoon_user_creation_request,
        **kwargs
    ):
        """Create a SORACOM Lagoon user  # noqa: E501

        Create a SORACOM Lagoon user.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.create_lagoon_user(lagoon_user_creation_request, async_req=True)
        >>> result = thread.get()

        Args:
            lagoon_user_creation_request (LagoonUserCreationRequest): request

        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:
            LagoonUserCreationResponse
                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['lagoon_user_creation_request'] = \
            lagoon_user_creation_request
        return self.create_lagoon_user_endpoint.call_with_http_info(**kwargs)

    def delete_lagoon_user(
        self,
        lagoon_user_id,
        **kwargs
    ):
        """Delete a SORACOM Lagoon user  # noqa: E501

        Delete a SORACOM Lagoon user.  # 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_lagoon_user(lagoon_user_id, async_req=True)
        >>> result = thread.get()

        Args:
            lagoon_user_id (int): Target ID of the lagoon user

        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['lagoon_user_id'] = \
            lagoon_user_id
        return self.delete_lagoon_user_endpoint.call_with_http_info(**kwargs)

    def get_image_link(
        self,
        **kwargs
    ):
        """Get a custom icon image link of SORACOM Lagoon  # noqa: E501

        Get a custom icon image link of SORACOM Lagoon  # 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_image_link(async_req=True)
        >>> result = thread.get()


        Keyword Args:
            classic (bool): If the value is true, a request will be issued to Lagoon Classic. This is only valid if both Lagoon and Lagoon Classic are enabled.. [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:
            str
                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.get_image_link_endpoint.call_with_http_info(**kwargs)

    def get_lagoon_migration_info(
        self,
        lagoon_plan_changing_request,
        **kwargs
    ):
        """Get the version migration information for SORACOM Lagoon  # noqa: E501

        Get the version migration information for SORACOM Lagoon. Only the root account can operate this.  # 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_lagoon_migration_info(lagoon_plan_changing_request, async_req=True)
        >>> result = thread.get()

        Args:
            lagoon_plan_changing_request (LagoonPlanChangingRequest): req

        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['lagoon_plan_changing_request'] = \
            lagoon_plan_changing_request
        return self.get_lagoon_migration_info_endpoint.call_with_http_info(**kwargs)

    def initialize_lagoon_dashboard_permissions(
        self,
        dashboard_id,
        **kwargs
    ):
        """Update permissions to the initial state for a dashboard of SORACOM Lagoon  # noqa: E501

        Update permissions to the initial state for a dashboard of SORACOM Lagoon  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.initialize_lagoon_dashboard_permissions(dashboard_id, async_req=True)
        >>> result = thread.get()

        Args:
            dashboard_id (int): dashboard_id

        Keyword Args:
            classic (bool): If the value is true, a request will be issued to Lagoon Classic. This is only valid if both Lagoon and Lagoon Classic are enabled.. [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:
            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['dashboard_id'] = \
            dashboard_id
        return self.initialize_lagoon_dashboard_permissions_endpoint.call_with_http_info(**kwargs)

    def list_lagoon_dashboards_permissions(
        self,
        **kwargs
    ):
        """List permissions for all SORACOM Lagoon dashboards  # noqa: E501

        List permissions for all SORACOM Lagoon dashboards  # 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_lagoon_dashboards_permissions(async_req=True)
        >>> result = thread.get()


        Keyword Args:
            classic (bool): If the value is true, a request will be issued to Lagoon Classic. This is only valid if both Lagoon and Lagoon Classic are enabled.. [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:
            [LagoonDashboardPermissionsResponse]
                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_lagoon_dashboards_permissions_endpoint.call_with_http_info(**kwargs)

    def list_lagoon_license_pack_status(
        self,
        **kwargs
    ):
        """Get the status of active SORACOM Lagoon license packs  # noqa: E501

        Get the status of active SORACOM Lagoon license packs  # 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_lagoon_license_pack_status(async_req=True)
        >>> result = thread.get()


        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:
            [LagoonLicensePackStatusResponse]
                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_lagoon_license_pack_status_endpoint.call_with_http_info(**kwargs)

    def list_lagoon_users(
        self,
        **kwargs
    ):
        """List SORACOM Lagoon users that belong to operator  # noqa: E501

        List SORACOM Lagoon users that belong to operator.  # 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_lagoon_users(async_req=True)
        >>> result = thread.get()


        Keyword Args:
            classic (bool): If the value is true, a request will be issued to Lagoon Classic. This is only valid if both Lagoon and Lagoon Classic are enabled.. [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:
            [LagoonUser]
                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_lagoon_users_endpoint.call_with_http_info(**kwargs)

    def migrate_lagoon(
        self,
        lagoon_migration_from_classic_request,
        **kwargs
    ):
        """Migrate SORACOM Lagoon version  # noqa: E501

        Migrate SORACOM Lagoon version. Only the root account can operate this.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.migrate_lagoon(lagoon_migration_from_classic_request, async_req=True)
        >>> result = thread.get()

        Args:
            lagoon_migration_from_classic_request (LagoonMigrationFromClassicRequest): req

        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['lagoon_migration_from_classic_request'] = \
            lagoon_migration_from_classic_request
        return self.migrate_lagoon_endpoint.call_with_http_info(**kwargs)

    def register_lagoon(
        self,
        lagoon_registration_request,
        **kwargs
    ):
        """Register (activate) SORACOM Lagoon  # noqa: E501

        Register (activate) SORACOM Lagoon. This API is only allowed to operate by root account.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.register_lagoon(lagoon_registration_request, async_req=True)
        >>> result = thread.get()

        Args:
            lagoon_registration_request (LagoonRegistrationRequest): request

        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:
            LagoonRegistrationResponse
                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['lagoon_registration_request'] = \
            lagoon_registration_request
        return self.register_lagoon_endpoint.call_with_http_info(**kwargs)

    def terminate_lagoon(
        self,
        **kwargs
    ):
        """Terminate (deactivate) SORACOM Lagoon  # noqa: E501

        Terminate (deactivate) SORACOM Lagoon.  # 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_lagoon(async_req=True)
        >>> result = thread.get()


        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')
        return self.terminate_lagoon_endpoint.call_with_http_info(**kwargs)

    def update_lagoon_dashboard_permissions(
        self,
        dashboard_id,
        lagoon_dashboard_permissions_updating_request,
        **kwargs
    ):
        """Update permissions for a dashboard of SORACOM Lagoon  # noqa: E501

        Update permissions for a dashboard of SORACOM Lagoon  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.update_lagoon_dashboard_permissions(dashboard_id, lagoon_dashboard_permissions_updating_request, async_req=True)
        >>> result = thread.get()

        Args:
            dashboard_id (int): dashboard_id
            lagoon_dashboard_permissions_updating_request (LagoonDashboardPermissionsUpdatingRequest): req

        Keyword Args:
            classic (bool): If the value is true, a request will be issued to Lagoon Classic. This is only valid if both Lagoon and Lagoon Classic are enabled.. [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:
            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['dashboard_id'] = \
            dashboard_id
        kwargs['lagoon_dashboard_permissions_updating_request'] = \
            lagoon_dashboard_permissions_updating_request
        return self.update_lagoon_dashboard_permissions_endpoint.call_with_http_info(**kwargs)

    def update_lagoon_license_pack(
        self,
        lagoon_license_packs_updating_request,
        **kwargs
    ):
        """Update the quantities for license packs of SORACOM Lagoon  # noqa: E501

        Update the quantities for license packs of SORACOM Lagoon. This API is only allowed to operate by root account.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.update_lagoon_license_pack(lagoon_license_packs_updating_request, async_req=True)
        >>> result = thread.get()

        Args:
            lagoon_license_packs_updating_request (LagoonLicensePacksUpdatingRequest): req

        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['lagoon_license_packs_updating_request'] = \
            lagoon_license_packs_updating_request
        return self.update_lagoon_license_pack_endpoint.call_with_http_info(**kwargs)

    def update_lagoon_plan(
        self,
        lagoon_plan_changing_request,
        **kwargs
    ):
        """Update the plan of SORACOM Lagoon  # noqa: E501

        Update the plan of SORACOM Lagoon. This API is only allowed to operate by root account.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.update_lagoon_plan(lagoon_plan_changing_request, async_req=True)
        >>> result = thread.get()

        Args:
            lagoon_plan_changing_request (LagoonPlanChangingRequest): req

        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['lagoon_plan_changing_request'] = \
            lagoon_plan_changing_request
        return self.update_lagoon_plan_endpoint.call_with_http_info(**kwargs)

    def update_lagoon_user_email(
        self,
        lagoon_user_id,
        lagoon_user_email_updating_request,
        **kwargs
    ):
        """Update email address of a SORACOM Lagoon user  # noqa: E501

        Update email address of a SORACOM Lagoon user.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.update_lagoon_user_email(lagoon_user_id, lagoon_user_email_updating_request, async_req=True)
        >>> result = thread.get()

        Args:
            lagoon_user_id (int): Target ID of the lagoon user
            lagoon_user_email_updating_request (LagoonUserEmailUpdatingRequest): request

        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['lagoon_user_id'] = \
            lagoon_user_id
        kwargs['lagoon_user_email_updating_request'] = \
            lagoon_user_email_updating_request
        return self.update_lagoon_user_email_endpoint.call_with_http_info(**kwargs)

    def update_lagoon_user_password(
        self,
        lagoon_user_id,
        lagoon_user_password_updating_request,
        **kwargs
    ):
        """Update password of a SORACOM Lagoon user  # noqa: E501

        Update password of a SORACOM Lagoon user.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.update_lagoon_user_password(lagoon_user_id, lagoon_user_password_updating_request, async_req=True)
        >>> result = thread.get()

        Args:
            lagoon_user_id (int): Target ID of the lagoon user
            lagoon_user_password_updating_request (LagoonUserPasswordUpdatingRequest): request

        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['lagoon_user_id'] = \
            lagoon_user_id
        kwargs['lagoon_user_password_updating_request'] = \
            lagoon_user_password_updating_request
        return self.update_lagoon_user_password_endpoint.call_with_http_info(**kwargs)

    def update_lagoon_user_permission(
        self,
        lagoon_user_id,
        lagoon_user_permission_updating_request,
        **kwargs
    ):
        """Update permission of a SORACOM Lagoon user  # noqa: E501

        Update permission of a SORACOM Lagoon user.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.update_lagoon_user_permission(lagoon_user_id, lagoon_user_permission_updating_request, async_req=True)
        >>> result = thread.get()

        Args:
            lagoon_user_id (int): Target ID of the lagoon user
            lagoon_user_permission_updating_request (LagoonUserPermissionUpdatingRequest): request

        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['lagoon_user_id'] = \
            lagoon_user_id
        kwargs['lagoon_user_permission_updating_request'] = \
            lagoon_user_permission_updating_request
        return self.update_lagoon_user_permission_endpoint.call_with_http_info(**kwargs)

