"""
    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.api_call_error import APICallError
from soracom_api.model.auth_key_response import AuthKeyResponse
from soracom_api.model.create_user_password_request import CreateUserPasswordRequest
from soracom_api.model.create_user_request import CreateUserRequest
from soracom_api.model.enable_mfaotp_response import EnableMFAOTPResponse
from soracom_api.model.generate_user_auth_key_response import GenerateUserAuthKeyResponse
from soracom_api.model.get_default_permissions_response import GetDefaultPermissionsResponse
from soracom_api.model.get_user_password_response import GetUserPasswordResponse
from soracom_api.model.get_user_permission_response import GetUserPermissionResponse
from soracom_api.model.mfa_authentication_request import MFAAuthenticationRequest
from soracom_api.model.mfa_status_of_use_response import MFAStatusOfUseResponse
from soracom_api.model.set_user_permission_request import SetUserPermissionRequest
from soracom_api.model.update_default_permissions_request import UpdateDefaultPermissionsRequest
from soracom_api.model.update_password_request import UpdatePasswordRequest
from soracom_api.model.update_user_request import UpdateUserRequest
from soracom_api.model.user_detail_response import UserDetailResponse


class UserApi(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_user_endpoint = _Endpoint(
            settings={
                'response_type': None,
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/operators/{operator_id}/users/{user_name}',
                'operation_id': 'create_user',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'operator_id',
                    'user_name',
                    'create_user_request',
                ],
                'required': [
                    'operator_id',
                    'user_name',
                    'create_user_request',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'operator_id':
                        (str,),
                    'user_name':
                        (str,),
                    'create_user_request':
                        (CreateUserRequest,),
                },
                'attribute_map': {
                    'operator_id': 'operator_id',
                    'user_name': 'user_name',
                },
                'location_map': {
                    'operator_id': 'path',
                    'user_name': 'path',
                    'create_user_request': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.create_user_password_endpoint = _Endpoint(
            settings={
                'response_type': None,
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/operators/{operator_id}/users/{user_name}/password',
                'operation_id': 'create_user_password',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'operator_id',
                    'user_name',
                    'create_user_password_request',
                ],
                'required': [
                    'operator_id',
                    'user_name',
                    'create_user_password_request',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'operator_id':
                        (str,),
                    'user_name':
                        (str,),
                    'create_user_password_request':
                        (CreateUserPasswordRequest,),
                },
                'attribute_map': {
                    'operator_id': 'operator_id',
                    'user_name': 'user_name',
                },
                'location_map': {
                    'operator_id': 'path',
                    'user_name': 'path',
                    'create_user_password_request': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.delete_user_endpoint = _Endpoint(
            settings={
                'response_type': None,
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/operators/{operator_id}/users/{user_name}',
                'operation_id': 'delete_user',
                'http_method': 'DELETE',
                'servers': None,
            },
            params_map={
                'all': [
                    'operator_id',
                    'user_name',
                ],
                'required': [
                    'operator_id',
                    'user_name',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'operator_id':
                        (str,),
                    'user_name':
                        (str,),
                },
                'attribute_map': {
                    'operator_id': 'operator_id',
                    'user_name': 'user_name',
                },
                'location_map': {
                    'operator_id': 'path',
                    'user_name': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json;charset=UTF-8'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.delete_user_auth_key_endpoint = _Endpoint(
            settings={
                'response_type': None,
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/operators/{operator_id}/users/{user_name}/auth_keys/{auth_key_id}',
                'operation_id': 'delete_user_auth_key',
                'http_method': 'DELETE',
                'servers': None,
            },
            params_map={
                'all': [
                    'operator_id',
                    'user_name',
                    'auth_key_id',
                ],
                'required': [
                    'operator_id',
                    'user_name',
                    'auth_key_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'operator_id':
                        (str,),
                    'user_name':
                        (str,),
                    'auth_key_id':
                        (str,),
                },
                'attribute_map': {
                    'operator_id': 'operator_id',
                    'user_name': 'user_name',
                    'auth_key_id': 'auth_key_id',
                },
                'location_map': {
                    'operator_id': 'path',
                    'user_name': 'path',
                    'auth_key_id': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json;charset=UTF-8'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.delete_user_password_endpoint = _Endpoint(
            settings={
                'response_type': None,
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/operators/{operator_id}/users/{user_name}/password',
                'operation_id': 'delete_user_password',
                'http_method': 'DELETE',
                'servers': None,
            },
            params_map={
                'all': [
                    'operator_id',
                    'user_name',
                ],
                'required': [
                    'operator_id',
                    'user_name',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'operator_id':
                        (str,),
                    'user_name':
                        (str,),
                },
                'attribute_map': {
                    'operator_id': 'operator_id',
                    'user_name': 'user_name',
                },
                'location_map': {
                    'operator_id': 'path',
                    'user_name': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json;charset=UTF-8'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.enable_user_mfa_endpoint = _Endpoint(
            settings={
                'response_type': (EnableMFAOTPResponse,),
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/operators/{operator_id}/users/{user_name}/mfa',
                'operation_id': 'enable_user_mfa',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'operator_id',
                    'user_name',
                ],
                'required': [
                    'operator_id',
                    'user_name',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'operator_id':
                        (str,),
                    'user_name':
                        (str,),
                },
                'attribute_map': {
                    'operator_id': 'operator_id',
                    'user_name': 'user_name',
                },
                'location_map': {
                    'operator_id': 'path',
                    'user_name': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.generate_user_auth_key_endpoint = _Endpoint(
            settings={
                'response_type': (GenerateUserAuthKeyResponse,),
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/operators/{operator_id}/users/{user_name}/auth_keys',
                'operation_id': 'generate_user_auth_key',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'operator_id',
                    'user_name',
                ],
                'required': [
                    'operator_id',
                    'user_name',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'operator_id':
                        (str,),
                    'user_name':
                        (str,),
                },
                'attribute_map': {
                    'operator_id': 'operator_id',
                    'user_name': 'user_name',
                },
                'location_map': {
                    'operator_id': 'path',
                    'user_name': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json;charset=UTF-8'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_default_permissions_endpoint = _Endpoint(
            settings={
                'response_type': (GetDefaultPermissionsResponse,),
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/operators/{operator_id}/users/default_permissions',
                'operation_id': 'get_default_permissions',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'operator_id',
                ],
                'required': [
                    'operator_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'operator_id':
                        (str,),
                },
                'attribute_map': {
                    'operator_id': 'operator_id',
                },
                'location_map': {
                    'operator_id': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json;charset=UTF-8'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_user_endpoint = _Endpoint(
            settings={
                'response_type': (UserDetailResponse,),
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/operators/{operator_id}/users/{user_name}',
                'operation_id': 'get_user',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'operator_id',
                    'user_name',
                ],
                'required': [
                    'operator_id',
                    'user_name',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'operator_id':
                        (str,),
                    'user_name':
                        (str,),
                },
                'attribute_map': {
                    'operator_id': 'operator_id',
                    'user_name': 'user_name',
                },
                'location_map': {
                    'operator_id': 'path',
                    'user_name': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json;charset=UTF-8'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_user_auth_key_endpoint = _Endpoint(
            settings={
                'response_type': (AuthKeyResponse,),
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/operators/{operator_id}/users/{user_name}/auth_keys/{auth_key_id}',
                'operation_id': 'get_user_auth_key',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'operator_id',
                    'user_name',
                    'auth_key_id',
                ],
                'required': [
                    'operator_id',
                    'user_name',
                    'auth_key_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'operator_id':
                        (str,),
                    'user_name':
                        (str,),
                    'auth_key_id':
                        (str,),
                },
                'attribute_map': {
                    'operator_id': 'operator_id',
                    'user_name': 'user_name',
                    'auth_key_id': 'auth_key_id',
                },
                'location_map': {
                    'operator_id': 'path',
                    'user_name': 'path',
                    'auth_key_id': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json;charset=UTF-8'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_user_mfa_status_endpoint = _Endpoint(
            settings={
                'response_type': (MFAStatusOfUseResponse,),
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/operators/{operator_id}/users/{user_name}/mfa',
                'operation_id': 'get_user_mfa_status',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'operator_id',
                    'user_name',
                ],
                'required': [
                    'operator_id',
                    'user_name',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'operator_id':
                        (str,),
                    'user_name':
                        (str,),
                },
                'attribute_map': {
                    'operator_id': 'operator_id',
                    'user_name': 'user_name',
                },
                'location_map': {
                    'operator_id': 'path',
                    'user_name': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_user_permission_endpoint = _Endpoint(
            settings={
                'response_type': (GetUserPermissionResponse,),
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/operators/{operator_id}/users/{user_name}/permission',
                'operation_id': 'get_user_permission',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'operator_id',
                    'user_name',
                ],
                'required': [
                    'operator_id',
                    'user_name',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'operator_id':
                        (str,),
                    'user_name':
                        (str,),
                },
                'attribute_map': {
                    'operator_id': 'operator_id',
                    'user_name': 'user_name',
                },
                'location_map': {
                    'operator_id': 'path',
                    'user_name': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json;charset=UTF-8'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.has_user_password_endpoint = _Endpoint(
            settings={
                'response_type': (GetUserPasswordResponse,),
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/operators/{operator_id}/users/{user_name}/password',
                'operation_id': 'has_user_password',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'operator_id',
                    'user_name',
                ],
                'required': [
                    'operator_id',
                    'user_name',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'operator_id':
                        (str,),
                    'user_name':
                        (str,),
                },
                'attribute_map': {
                    'operator_id': 'operator_id',
                    'user_name': 'user_name',
                },
                'location_map': {
                    'operator_id': 'path',
                    'user_name': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json;charset=UTF-8'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.list_user_auth_keys_endpoint = _Endpoint(
            settings={
                'response_type': ([AuthKeyResponse],),
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/operators/{operator_id}/users/{user_name}/auth_keys',
                'operation_id': 'list_user_auth_keys',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'operator_id',
                    'user_name',
                ],
                'required': [
                    'operator_id',
                    'user_name',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'operator_id':
                        (str,),
                    'user_name':
                        (str,),
                },
                'attribute_map': {
                    'operator_id': 'operator_id',
                    'user_name': 'user_name',
                },
                'location_map': {
                    'operator_id': 'path',
                    'user_name': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json;charset=UTF-8'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.list_users_endpoint = _Endpoint(
            settings={
                'response_type': ([UserDetailResponse],),
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/operators/{operator_id}/users',
                'operation_id': 'list_users',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'operator_id',
                ],
                'required': [
                    'operator_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'operator_id':
                        (str,),
                },
                'attribute_map': {
                    'operator_id': 'operator_id',
                },
                'location_map': {
                    'operator_id': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json;charset=UTF-8'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.revoke_user_mfa_endpoint = _Endpoint(
            settings={
                'response_type': None,
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/operators/{operator_id}/users/{user_name}/mfa',
                'operation_id': 'revoke_user_mfa',
                'http_method': 'DELETE',
                'servers': None,
            },
            params_map={
                'all': [
                    'operator_id',
                    'user_name',
                ],
                'required': [
                    'operator_id',
                    'user_name',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'operator_id':
                        (str,),
                    'user_name':
                        (str,),
                },
                'attribute_map': {
                    'operator_id': 'operator_id',
                    'user_name': 'user_name',
                },
                'location_map': {
                    'operator_id': 'path',
                    'user_name': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [],
                'content_type': [],
            },
            api_client=api_client
        )
        self.update_default_permissions_endpoint = _Endpoint(
            settings={
                'response_type': None,
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/operators/{operator_id}/users/default_permissions',
                'operation_id': 'update_default_permissions',
                'http_method': 'PUT',
                'servers': None,
            },
            params_map={
                'all': [
                    'operator_id',
                    'update_default_permissions_request',
                ],
                'required': [
                    'operator_id',
                    'update_default_permissions_request',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'operator_id':
                        (str,),
                    'update_default_permissions_request':
                        (UpdateDefaultPermissionsRequest,),
                },
                'attribute_map': {
                    'operator_id': 'operator_id',
                },
                'location_map': {
                    'operator_id': 'path',
                    'update_default_permissions_request': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.update_user_endpoint = _Endpoint(
            settings={
                'response_type': None,
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/operators/{operator_id}/users/{user_name}',
                'operation_id': 'update_user',
                'http_method': 'PUT',
                'servers': None,
            },
            params_map={
                'all': [
                    'operator_id',
                    'user_name',
                    'update_user_request',
                ],
                'required': [
                    'operator_id',
                    'user_name',
                    'update_user_request',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'operator_id':
                        (str,),
                    'user_name':
                        (str,),
                    'update_user_request':
                        (UpdateUserRequest,),
                },
                'attribute_map': {
                    'operator_id': 'operator_id',
                    'user_name': 'user_name',
                },
                'location_map': {
                    'operator_id': 'path',
                    'user_name': 'path',
                    'update_user_request': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json;charset=UTF-8'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.update_user_password_endpoint = _Endpoint(
            settings={
                'response_type': None,
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/operators/{operator_id}/users/{user_name}/password',
                'operation_id': 'update_user_password',
                'http_method': 'PUT',
                'servers': None,
            },
            params_map={
                'all': [
                    'operator_id',
                    'user_name',
                    'update_password_request',
                ],
                'required': [
                    'operator_id',
                    'user_name',
                    'update_password_request',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'operator_id':
                        (str,),
                    'user_name':
                        (str,),
                    'update_password_request':
                        (UpdatePasswordRequest,),
                },
                'attribute_map': {
                    'operator_id': 'operator_id',
                    'user_name': 'user_name',
                },
                'location_map': {
                    'operator_id': 'path',
                    'user_name': 'path',
                    'update_password_request': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.update_user_permission_endpoint = _Endpoint(
            settings={
                'response_type': None,
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/operators/{operator_id}/users/{user_name}/permission',
                'operation_id': 'update_user_permission',
                'http_method': 'PUT',
                'servers': None,
            },
            params_map={
                'all': [
                    'operator_id',
                    'user_name',
                    'set_user_permission_request',
                ],
                'required': [
                    'operator_id',
                    'user_name',
                    'set_user_permission_request',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'operator_id':
                        (str,),
                    'user_name':
                        (str,),
                    'set_user_permission_request':
                        (SetUserPermissionRequest,),
                },
                'attribute_map': {
                    'operator_id': 'operator_id',
                    'user_name': 'user_name',
                },
                'location_map': {
                    'operator_id': 'path',
                    'user_name': 'path',
                    'set_user_permission_request': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.verify_user_mfa_endpoint = _Endpoint(
            settings={
                'response_type': None,
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/operators/{operator_id}/users/{user_name}/mfa/verify',
                'operation_id': 'verify_user_mfa',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'operator_id',
                    'user_name',
                    'mfa_authentication_request',
                ],
                'required': [
                    'operator_id',
                    'user_name',
                    'mfa_authentication_request',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'operator_id':
                        (str,),
                    'user_name':
                        (str,),
                    'mfa_authentication_request':
                        (MFAAuthenticationRequest,),
                },
                'attribute_map': {
                    'operator_id': 'operator_id',
                    'user_name': 'user_name',
                },
                'location_map': {
                    'operator_id': 'path',
                    'user_name': 'path',
                    'mfa_authentication_request': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )

    def create_user(
        self,
        operator_id,
        user_name,
        create_user_request,
        **kwargs
    ):
        """Create User.  # noqa: E501

        Adds a new SAM 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_user(operator_id, user_name, create_user_request, async_req=True)
        >>> result = thread.get()

        Args:
            operator_id (str): operator_id
            user_name (str): user_name
            create_user_request (CreateUserRequest): description

        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['operator_id'] = \
            operator_id
        kwargs['user_name'] = \
            user_name
        kwargs['create_user_request'] = \
            create_user_request
        return self.create_user_endpoint.call_with_http_info(**kwargs)

    def create_user_password(
        self,
        operator_id,
        user_name,
        create_user_password_request,
        **kwargs
    ):
        """Create Password.  # noqa: E501

        Creates a password for the SAM 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_user_password(operator_id, user_name, create_user_password_request, async_req=True)
        >>> result = thread.get()

        Args:
            operator_id (str): operator_id
            user_name (str): user_name
            create_user_password_request (CreateUserPasswordRequest): password

        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['operator_id'] = \
            operator_id
        kwargs['user_name'] = \
            user_name
        kwargs['create_user_password_request'] = \
            create_user_password_request
        return self.create_user_password_endpoint.call_with_http_info(**kwargs)

    def delete_user(
        self,
        operator_id,
        user_name,
        **kwargs
    ):
        """Delete User.  # noqa: E501

        Deletes the SAM 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_user(operator_id, user_name, async_req=True)
        >>> result = thread.get()

        Args:
            operator_id (str): operator_id
            user_name (str): user_name

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

    def delete_user_auth_key(
        self,
        operator_id,
        user_name,
        auth_key_id,
        **kwargs
    ):
        """Delete User AuthKey.  # noqa: E501

        Deletes an AuthKey from the SAM 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_user_auth_key(operator_id, user_name, auth_key_id, async_req=True)
        >>> result = thread.get()

        Args:
            operator_id (str): operator_id
            user_name (str): user_name
            auth_key_id (str): auth_key_id

        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['operator_id'] = \
            operator_id
        kwargs['user_name'] = \
            user_name
        kwargs['auth_key_id'] = \
            auth_key_id
        return self.delete_user_auth_key_endpoint.call_with_http_info(**kwargs)

    def delete_user_password(
        self,
        operator_id,
        user_name,
        **kwargs
    ):
        """Delete Password.  # noqa: E501

        Deletes the user's password.  # 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_user_password(operator_id, user_name, async_req=True)
        >>> result = thread.get()

        Args:
            operator_id (str): operator_id
            user_name (str): user_name

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

    def enable_user_mfa(
        self,
        operator_id,
        user_name,
        **kwargs
    ):
        """Enable SAM user's MFA  # noqa: E501

        Enable SAM user's MFA  # 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_user_mfa(operator_id, user_name, async_req=True)
        >>> result = thread.get()

        Args:
            operator_id (str): Operator ID
            user_name (str): SAM user name

        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:
            EnableMFAOTPResponse
                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['operator_id'] = \
            operator_id
        kwargs['user_name'] = \
            user_name
        return self.enable_user_mfa_endpoint.call_with_http_info(**kwargs)

    def generate_user_auth_key(
        self,
        operator_id,
        user_name,
        **kwargs
    ):
        """Generate AuthKey.  # noqa: E501

        Generates an AuthKey for the SAM 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.generate_user_auth_key(operator_id, user_name, async_req=True)
        >>> result = thread.get()

        Args:
            operator_id (str): operator_id
            user_name (str): user_name

        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:
            GenerateUserAuthKeyResponse
                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['operator_id'] = \
            operator_id
        kwargs['user_name'] = \
            user_name
        return self.generate_user_auth_key_endpoint.call_with_http_info(**kwargs)

    def get_default_permissions(
        self,
        operator_id,
        **kwargs
    ):
        """Get the default permissions  # noqa: E501

        Get the default permissions rule that is applied to all of the SAM users  # 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_default_permissions(operator_id, async_req=True)
        >>> result = thread.get()

        Args:
            operator_id (str): Operator ID

        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:
            GetDefaultPermissionsResponse
                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['operator_id'] = \
            operator_id
        return self.get_default_permissions_endpoint.call_with_http_info(**kwargs)

    def get_user(
        self,
        operator_id,
        user_name,
        **kwargs
    ):
        """Get User.  # noqa: E501

        Returns a SAM 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.get_user(operator_id, user_name, async_req=True)
        >>> result = thread.get()

        Args:
            operator_id (str): operator_id
            user_name (str): user_name

        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:
            UserDetailResponse
                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['operator_id'] = \
            operator_id
        kwargs['user_name'] = \
            user_name
        return self.get_user_endpoint.call_with_http_info(**kwargs)

    def get_user_auth_key(
        self,
        operator_id,
        user_name,
        auth_key_id,
        **kwargs
    ):
        """Get AuthKey.  # noqa: E501

        Returns the SAM user's AuthKey.  # 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_user_auth_key(operator_id, user_name, auth_key_id, async_req=True)
        >>> result = thread.get()

        Args:
            operator_id (str): operator_id
            user_name (str): user_name
            auth_key_id (str): auth_key_id

        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:
            AuthKeyResponse
                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['operator_id'] = \
            operator_id
        kwargs['user_name'] = \
            user_name
        kwargs['auth_key_id'] = \
            auth_key_id
        return self.get_user_auth_key_endpoint.call_with_http_info(**kwargs)

    def get_user_mfa_status(
        self,
        operator_id,
        user_name,
        **kwargs
    ):
        """Get SAM user's MFA status  # noqa: E501

        Get SAM user's MFA status  # 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_user_mfa_status(operator_id, user_name, async_req=True)
        >>> result = thread.get()

        Args:
            operator_id (str): Operator ID
            user_name (str): SAM user name

        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:
            MFAStatusOfUseResponse
                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['operator_id'] = \
            operator_id
        kwargs['user_name'] = \
            user_name
        return self.get_user_mfa_status_endpoint.call_with_http_info(**kwargs)

    def get_user_permission(
        self,
        operator_id,
        user_name,
        **kwargs
    ):
        """Get User Permission.  # noqa: E501

        Retrieves the SAM user's permissions.  # 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_user_permission(operator_id, user_name, async_req=True)
        >>> result = thread.get()

        Args:
            operator_id (str): operator_id
            user_name (str): user_name

        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:
            GetUserPermissionResponse
                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['operator_id'] = \
            operator_id
        kwargs['user_name'] = \
            user_name
        return self.get_user_permission_endpoint.call_with_http_info(**kwargs)

    def has_user_password(
        self,
        operator_id,
        user_name,
        **kwargs
    ):
        """Has User Password.  # noqa: E501

        Retrieves whether the SAM user has a password or not.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.has_user_password(operator_id, user_name, async_req=True)
        >>> result = thread.get()

        Args:
            operator_id (str): operator_id
            user_name (str): user_name

        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:
            GetUserPasswordResponse
                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['operator_id'] = \
            operator_id
        kwargs['user_name'] = \
            user_name
        return self.has_user_password_endpoint.call_with_http_info(**kwargs)

    def list_user_auth_keys(
        self,
        operator_id,
        user_name,
        **kwargs
    ):
        """List User AuthKeys.  # noqa: E501

        Returns the SAM user's AuthKey list.  # 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_user_auth_keys(operator_id, user_name, async_req=True)
        >>> result = thread.get()

        Args:
            operator_id (str): operator_id
            user_name (str): user_name

        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:
            [AuthKeyResponse]
                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['operator_id'] = \
            operator_id
        kwargs['user_name'] = \
            user_name
        return self.list_user_auth_keys_endpoint.call_with_http_info(**kwargs)

    def list_users(
        self,
        operator_id,
        **kwargs
    ):
        """List Users.  # noqa: E501

        Returns a list of SAM users.  # 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_users(operator_id, async_req=True)
        >>> result = thread.get()

        Args:
            operator_id (str): operator_id

        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:
            [UserDetailResponse]
                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['operator_id'] = \
            operator_id
        return self.list_users_endpoint.call_with_http_info(**kwargs)

    def revoke_user_mfa(
        self,
        operator_id,
        user_name,
        **kwargs
    ):
        """Revoke SAM user's MFA  # noqa: E501

        Revoke SAM user's MFA  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.revoke_user_mfa(operator_id, user_name, async_req=True)
        >>> result = thread.get()

        Args:
            operator_id (str): Operator ID
            user_name (str): SAM user name

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

    def update_default_permissions(
        self,
        operator_id,
        update_default_permissions_request,
        **kwargs
    ):
        """Update the default permissions  # noqa: E501

        Update the default permissions rule that is applied to all of the SAM  # 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_default_permissions(operator_id, update_default_permissions_request, async_req=True)
        >>> result = thread.get()

        Args:
            operator_id (str): Operator ID
            update_default_permissions_request (UpdateDefaultPermissionsRequest): 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['operator_id'] = \
            operator_id
        kwargs['update_default_permissions_request'] = \
            update_default_permissions_request
        return self.update_default_permissions_endpoint.call_with_http_info(**kwargs)

    def update_user(
        self,
        operator_id,
        user_name,
        update_user_request,
        **kwargs
    ):
        """Update User.  # noqa: E501

        Updates the SAM 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_user(operator_id, user_name, update_user_request, async_req=True)
        >>> result = thread.get()

        Args:
            operator_id (str): operator_id
            user_name (str): user_name
            update_user_request (UpdateUserRequest): description

        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['operator_id'] = \
            operator_id
        kwargs['user_name'] = \
            user_name
        kwargs['update_user_request'] = \
            update_user_request
        return self.update_user_endpoint.call_with_http_info(**kwargs)

    def update_user_password(
        self,
        operator_id,
        user_name,
        update_password_request,
        **kwargs
    ):
        """Update Password.  # noqa: E501

        Updates the password of the SAM 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_user_password(operator_id, user_name, update_password_request, async_req=True)
        >>> result = thread.get()

        Args:
            operator_id (str): operator_id
            user_name (str): user_name
            update_password_request (UpdatePasswordRequest): password

        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['operator_id'] = \
            operator_id
        kwargs['user_name'] = \
            user_name
        kwargs['update_password_request'] = \
            update_password_request
        return self.update_user_password_endpoint.call_with_http_info(**kwargs)

    def update_user_permission(
        self,
        operator_id,
        user_name,
        set_user_permission_request,
        **kwargs
    ):
        """Update Permission to User.  # noqa: E501

        Updates the SAM user's permissions.  # 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_user_permission(operator_id, user_name, set_user_permission_request, async_req=True)
        >>> result = thread.get()

        Args:
            operator_id (str): operator_id
            user_name (str): user_name
            set_user_permission_request (SetUserPermissionRequest): permission

        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['operator_id'] = \
            operator_id
        kwargs['user_name'] = \
            user_name
        kwargs['set_user_permission_request'] = \
            set_user_permission_request
        return self.update_user_permission_endpoint.call_with_http_info(**kwargs)

    def verify_user_mfa(
        self,
        operator_id,
        user_name,
        mfa_authentication_request,
        **kwargs
    ):
        """Verify SAM user's MFA OTP code when MFA activation phase  # noqa: E501

        Verify SAM user's MFA OTP code when MFA activation phase  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.verify_user_mfa(operator_id, user_name, mfa_authentication_request, async_req=True)
        >>> result = thread.get()

        Args:
            operator_id (str): Operator ID
            user_name (str): SAM user name
            mfa_authentication_request (MFAAuthenticationRequest): 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['operator_id'] = \
            operator_id
        kwargs['user_name'] = \
            user_name
        kwargs['mfa_authentication_request'] = \
            mfa_authentication_request
        return self.verify_user_mfa_endpoint.call_with_http_info(**kwargs)

