"""
    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.arc_credential_attach_request import ArcCredentialAttachRequest
from soracom_api.model.arc_credential_attach_response import ArcCredentialAttachResponse
from soracom_api.model.arc_credential_renew_request import ArcCredentialRenewRequest
from soracom_api.model.arc_credential_renew_response import ArcCredentialRenewResponse
from soracom_api.model.arc_session_create_response import ArcSessionCreateResponse
from soracom_api.model.create_sim_request import CreateSimRequest
from soracom_api.model.data_entry import DataEntry
from soracom_api.model.downlink_ping_request import DownlinkPingRequest
from soracom_api.model.downlink_ping_response import DownlinkPingResponse
from soracom_api.model.expiry_time import ExpiryTime
from soracom_api.model.inline_object3 import InlineObject3
from soracom_api.model.mapping_entries import MappingEntries
from soracom_api.model.packet_capture_session import PacketCaptureSession
from soracom_api.model.packet_capture_session_request import PacketCaptureSessionRequest
from soracom_api.model.register_sim_request import RegisterSimRequest
from soracom_api.model.session_event import SessionEvent
from soracom_api.model.set_group_request import SetGroupRequest
from soracom_api.model.set_imei_lock_request import SetImeiLockRequest
from soracom_api.model.sim import Sim
from soracom_api.model.sim_profile import SimProfile
from soracom_api.model.sms_forwarding_report import SmsForwardingReport
from soracom_api.model.sms_forwarding_request import SmsForwardingRequest
from soracom_api.model.subscriber import Subscriber
from soracom_api.model.subscription_container_status import SubscriptionContainerStatus
from soracom_api.model.tag_update_request import TagUpdateRequest
from soracom_api.model.update_speed_class_request import UpdateSpeedClassRequest


class SimApi(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.activate_sim_endpoint = _Endpoint(
            settings={
                'response_type': (Sim,),
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/sims/{sim_id}/activate',
                'operation_id': 'activate_sim',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'sim_id',
                ],
                'required': [
                    'sim_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'sim_id':
                        (str,),
                },
                'attribute_map': {
                    'sim_id': 'sim_id',
                },
                'location_map': {
                    'sim_id': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.add_subscription_endpoint = _Endpoint(
            settings={
                'response_type': (SimProfile,),
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/sims/{sim_id}/profiles/{iccid}/add_subscription',
                'operation_id': 'add_subscription',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'sim_id',
                    'iccid',
                    'inline_object3',
                ],
                'required': [
                    'sim_id',
                    'iccid',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'sim_id':
                        (str,),
                    'iccid':
                        (str,),
                    'inline_object3':
                        (InlineObject3,),
                },
                'attribute_map': {
                    'sim_id': 'sim_id',
                    'iccid': 'iccid',
                },
                'location_map': {
                    'sim_id': 'path',
                    'iccid': 'path',
                    'inline_object3': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.attach_arc_sim_credentials_endpoint = _Endpoint(
            settings={
                'response_type': (ArcCredentialAttachResponse,),
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/sims/{sim_id}/credentials/arc',
                'operation_id': 'attach_arc_sim_credentials',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'sim_id',
                    'arc_credential_attach_request',
                ],
                'required': [
                    'sim_id',
                    'arc_credential_attach_request',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'sim_id':
                        (str,),
                    'arc_credential_attach_request':
                        (ArcCredentialAttachRequest,),
                },
                'attribute_map': {
                    'sim_id': 'sim_id',
                },
                'location_map': {
                    'sim_id': 'path',
                    'arc_credential_attach_request': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.cancel_subscription_container_download_endpoint = _Endpoint(
            settings={
                'response_type': (SubscriptionContainerStatus,),
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/sims/{sim_id}/profiles/{iccid}/subscribers/{imsi}/cancel_download',
                'operation_id': 'cancel_subscription_container_download',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'sim_id',
                    'iccid',
                    'imsi',
                ],
                'required': [
                    'sim_id',
                    'iccid',
                    'imsi',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'sim_id':
                        (str,),
                    'iccid':
                        (str,),
                    'imsi':
                        (str,),
                },
                'attribute_map': {
                    'sim_id': 'sim_id',
                    'iccid': 'iccid',
                    'imsi': 'imsi',
                },
                'location_map': {
                    'sim_id': 'path',
                    'iccid': 'path',
                    'imsi': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.create_arc_session_endpoint = _Endpoint(
            settings={
                'response_type': (ArcSessionCreateResponse,),
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/sims/{sim_id}/sessions/arc',
                'operation_id': 'create_arc_session',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'sim_id',
                ],
                'required': [
                    'sim_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'sim_id':
                        (str,),
                },
                'attribute_map': {
                    'sim_id': 'sim_id',
                },
                'location_map': {
                    'sim_id': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.create_sim_endpoint = _Endpoint(
            settings={
                'response_type': (Sim,),
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/sims',
                'operation_id': 'create_sim',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'create_sim_request',
                ],
                'required': [
                    'create_sim_request',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'create_sim_request':
                        (CreateSimRequest,),
                },
                'attribute_map': {
                },
                'location_map': {
                    'create_sim_request': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.create_sim_packet_capture_session_endpoint = _Endpoint(
            settings={
                'response_type': (PacketCaptureSession,),
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/sims/{sim_id}/packet_capture_sessions',
                'operation_id': 'create_sim_packet_capture_session',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'sim_id',
                    'packet_capture_session_request',
                ],
                'required': [
                    'sim_id',
                    'packet_capture_session_request',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'sim_id':
                        (str,),
                    'packet_capture_session_request':
                        (PacketCaptureSessionRequest,),
                },
                'attribute_map': {
                    'sim_id': 'sim_id',
                },
                'location_map': {
                    'sim_id': 'path',
                    'packet_capture_session_request': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.deactivate_sim_endpoint = _Endpoint(
            settings={
                'response_type': (Sim,),
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/sims/{sim_id}/deactivate',
                'operation_id': 'deactivate_sim',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'sim_id',
                ],
                'required': [
                    'sim_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'sim_id':
                        (str,),
                },
                'attribute_map': {
                    'sim_id': 'sim_id',
                },
                'location_map': {
                    'sim_id': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.delete_sim_packet_capture_session_endpoint = _Endpoint(
            settings={
                'response_type': (PacketCaptureSession,),
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/sims/{sim_id}/packet_capture_sessions/{session_id}',
                'operation_id': 'delete_sim_packet_capture_session',
                'http_method': 'DELETE',
                'servers': None,
            },
            params_map={
                'all': [
                    'sim_id',
                    'session_id',
                ],
                'required': [
                    'sim_id',
                    'session_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'sim_id':
                        (str,),
                    'session_id':
                        (str,),
                },
                'attribute_map': {
                    'sim_id': 'sim_id',
                    'session_id': 'session_id',
                },
                'location_map': {
                    'sim_id': 'path',
                    'session_id': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.delete_sim_session_endpoint = _Endpoint(
            settings={
                'response_type': (Sim,),
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/sims/{sim_id}/delete_session',
                'operation_id': 'delete_sim_session',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'sim_id',
                ],
                'required': [
                    'sim_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'sim_id':
                        (str,),
                },
                'attribute_map': {
                    'sim_id': 'sim_id',
                },
                'location_map': {
                    'sim_id': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.delete_sim_tag_endpoint = _Endpoint(
            settings={
                'response_type': None,
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/sims/{sim_id}/tags/{tag_name}',
                'operation_id': 'delete_sim_tag',
                'http_method': 'DELETE',
                'servers': None,
            },
            params_map={
                'all': [
                    'sim_id',
                    'tag_name',
                ],
                'required': [
                    'sim_id',
                    'tag_name',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'sim_id':
                        (str,),
                    'tag_name':
                        (str,),
                },
                'attribute_map': {
                    'sim_id': 'sim_id',
                    'tag_name': 'tag_name',
                },
                'location_map': {
                    'sim_id': 'path',
                    'tag_name': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [],
                'content_type': [],
            },
            api_client=api_client
        )
        self.delete_subscription_container_country_mapping_entry_endpoint = _Endpoint(
            settings={
                'response_type': (SubscriptionContainerStatus,),
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/sims/{sim_id}/profiles/{iccid}/subscription_containers/country_mapping/{mcc}',
                'operation_id': 'delete_subscription_container_country_mapping_entry',
                'http_method': 'DELETE',
                'servers': None,
            },
            params_map={
                'all': [
                    'sim_id',
                    'iccid',
                    'mcc',
                ],
                'required': [
                    'sim_id',
                    'iccid',
                    'mcc',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'sim_id':
                        (str,),
                    'iccid':
                        (str,),
                    'mcc':
                        (str,),
                },
                'attribute_map': {
                    'sim_id': 'sim_id',
                    'iccid': 'iccid',
                    'mcc': 'mcc',
                },
                'location_map': {
                    'sim_id': 'path',
                    'iccid': 'path',
                    'mcc': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.disable_sim_termination_endpoint = _Endpoint(
            settings={
                'response_type': (Sim,),
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/sims/{sim_id}/disable_termination',
                'operation_id': 'disable_sim_termination',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'sim_id',
                ],
                'required': [
                    'sim_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'sim_id':
                        (str,),
                },
                'attribute_map': {
                    'sim_id': 'sim_id',
                },
                'location_map': {
                    'sim_id': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.downlink_ping_to_user_equipment_endpoint = _Endpoint(
            settings={
                'response_type': (DownlinkPingResponse,),
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/sims/{sim_id}/downlink/ping',
                'operation_id': 'downlink_ping_to_user_equipment',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'sim_id',
                    'downlink_ping_request',
                ],
                'required': [
                    'sim_id',
                    'downlink_ping_request',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'sim_id':
                        (str,),
                    'downlink_ping_request':
                        (DownlinkPingRequest,),
                },
                'attribute_map': {
                    'sim_id': 'sim_id',
                },
                'location_map': {
                    'sim_id': 'path',
                    'downlink_ping_request': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.enable_sim_termination_endpoint = _Endpoint(
            settings={
                'response_type': (Sim,),
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/sims/{sim_id}/enable_termination',
                'operation_id': 'enable_sim_termination',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'sim_id',
                ],
                'required': [
                    'sim_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'sim_id':
                        (str,),
                },
                'attribute_map': {
                    'sim_id': 'sim_id',
                },
                'location_map': {
                    'sim_id': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.enable_subscription_container_endpoint = _Endpoint(
            settings={
                'response_type': (SubscriptionContainerStatus,),
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/sims/{sim_id}/profiles/{iccid}/subscription_containers/{containerId}/enable',
                'operation_id': 'enable_subscription_container',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'sim_id',
                    'iccid',
                    'container_id',
                ],
                'required': [
                    'sim_id',
                    'iccid',
                    'container_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'sim_id':
                        (str,),
                    'iccid':
                        (str,),
                    'container_id':
                        (str,),
                },
                'attribute_map': {
                    'sim_id': 'sim_id',
                    'iccid': 'iccid',
                    'container_id': 'containerId',
                },
                'location_map': {
                    'sim_id': 'path',
                    'iccid': 'path',
                    'container_id': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_data_from_sim_endpoint = _Endpoint(
            settings={
                'response_type': ([DataEntry],),
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/sims/{sim_id}/data',
                'operation_id': 'get_data_from_sim',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'sim_id',
                    '_from',
                    'to',
                    'sort',
                    'limit',
                    'last_evaluated_key',
                ],
                'required': [
                    'sim_id',
                ],
                'nullable': [
                ],
                'enum': [
                    'sort',
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                    ('sort',): {

                        "DESC": "desc",
                        "ASC": "asc"
                    },
                },
                'openapi_types': {
                    'sim_id':
                        (str,),
                    '_from':
                        (int,),
                    'to':
                        (int,),
                    'sort':
                        (str,),
                    'limit':
                        (int,),
                    'last_evaluated_key':
                        (str,),
                },
                'attribute_map': {
                    'sim_id': 'sim_id',
                    '_from': 'from',
                    'to': 'to',
                    'sort': 'sort',
                    'limit': 'limit',
                    'last_evaluated_key': 'last_evaluated_key',
                },
                'location_map': {
                    'sim_id': 'path',
                    '_from': 'query',
                    'to': 'query',
                    'sort': 'query',
                    'limit': 'query',
                    'last_evaluated_key': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_sim_endpoint = _Endpoint(
            settings={
                'response_type': (Sim,),
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/sims/{sim_id}',
                'operation_id': 'get_sim',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'sim_id',
                ],
                'required': [
                    'sim_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'sim_id':
                        (str,),
                },
                'attribute_map': {
                    'sim_id': 'sim_id',
                },
                'location_map': {
                    'sim_id': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.get_sim_packet_capture_session_endpoint = _Endpoint(
            settings={
                'response_type': (PacketCaptureSession,),
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/sims/{sim_id}/packet_capture_sessions/{session_id}',
                'operation_id': 'get_sim_packet_capture_session',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'sim_id',
                    'session_id',
                ],
                'required': [
                    'sim_id',
                    'session_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'sim_id':
                        (str,),
                    'session_id':
                        (str,),
                },
                'attribute_map': {
                    'sim_id': 'sim_id',
                    'session_id': 'session_id',
                },
                'location_map': {
                    'sim_id': 'path',
                    'session_id': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.list_sim_packet_capture_sessions_endpoint = _Endpoint(
            settings={
                'response_type': ([PacketCaptureSession],),
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/sims/{sim_id}/packet_capture_sessions',
                'operation_id': 'list_sim_packet_capture_sessions',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'sim_id',
                    'last_evaluated_key',
                    'limit',
                ],
                'required': [
                    'sim_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'sim_id':
                        (str,),
                    'last_evaluated_key':
                        (str,),
                    'limit':
                        (int,),
                },
                'attribute_map': {
                    'sim_id': 'sim_id',
                    'last_evaluated_key': 'last_evaluated_key',
                    'limit': 'limit',
                },
                'location_map': {
                    'sim_id': 'path',
                    'last_evaluated_key': 'query',
                    'limit': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.list_sim_session_events_endpoint = _Endpoint(
            settings={
                'response_type': ([SessionEvent],),
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/sims/{sim_id}/events/sessions',
                'operation_id': 'list_sim_session_events',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'sim_id',
                    '_from',
                    'to',
                    'limit',
                    'last_evaluated_key',
                ],
                'required': [
                    'sim_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'sim_id':
                        (str,),
                    '_from':
                        (int,),
                    'to':
                        (int,),
                    'limit':
                        (int,),
                    'last_evaluated_key':
                        (str,),
                },
                'attribute_map': {
                    'sim_id': 'sim_id',
                    '_from': 'from',
                    'to': 'to',
                    'limit': 'limit',
                    'last_evaluated_key': 'last_evaluated_key',
                },
                'location_map': {
                    'sim_id': 'path',
                    '_from': 'query',
                    'to': 'query',
                    'limit': 'query',
                    'last_evaluated_key': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.list_sims_endpoint = _Endpoint(
            settings={
                'response_type': ([Sim],),
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/sims',
                'operation_id': 'list_sims',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'limit',
                    'last_evaluated_key',
                ],
                'required': [],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'limit':
                        (int,),
                    'last_evaluated_key':
                        (str,),
                },
                'attribute_map': {
                    'limit': 'limit',
                    'last_evaluated_key': 'last_evaluated_key',
                },
                'location_map': {
                    'limit': 'query',
                    'last_evaluated_key': 'query',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.list_subscription_containers_endpoint = _Endpoint(
            settings={
                'response_type': (SubscriptionContainerStatus,),
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/sims/{sim_id}/profiles/{iccid}/subscription_containers',
                'operation_id': 'list_subscription_containers',
                'http_method': 'GET',
                'servers': None,
            },
            params_map={
                'all': [
                    'sim_id',
                    'iccid',
                ],
                'required': [
                    'sim_id',
                    'iccid',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'sim_id':
                        (str,),
                    'iccid':
                        (str,),
                },
                'attribute_map': {
                    'sim_id': 'sim_id',
                    'iccid': 'iccid',
                },
                'location_map': {
                    'sim_id': 'path',
                    'iccid': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.put_sim_tags_endpoint = _Endpoint(
            settings={
                'response_type': (Sim,),
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/sims/{sim_id}/tags',
                'operation_id': 'put_sim_tags',
                'http_method': 'PUT',
                'servers': None,
            },
            params_map={
                'all': [
                    'sim_id',
                    'tag_update_request',
                ],
                'required': [
                    'sim_id',
                    'tag_update_request',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'sim_id':
                        (str,),
                    'tag_update_request':
                        ([TagUpdateRequest],),
                },
                'attribute_map': {
                    'sim_id': 'sim_id',
                },
                'location_map': {
                    'sim_id': 'path',
                    'tag_update_request': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.put_subscription_container_country_mapping_entries_endpoint = _Endpoint(
            settings={
                'response_type': (SubscriptionContainerStatus,),
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/sims/{sim_id}/profiles/{iccid}/subscription_containers/country_mapping',
                'operation_id': 'put_subscription_container_country_mapping_entries',
                'http_method': 'PUT',
                'servers': None,
            },
            params_map={
                'all': [
                    'sim_id',
                    'iccid',
                    'mapping_entries',
                ],
                'required': [
                    'sim_id',
                    'iccid',
                    'mapping_entries',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'sim_id':
                        (str,),
                    'iccid':
                        (str,),
                    'mapping_entries':
                        (MappingEntries,),
                },
                'attribute_map': {
                    'sim_id': 'sim_id',
                    'iccid': 'iccid',
                },
                'location_map': {
                    'sim_id': 'path',
                    'iccid': 'path',
                    'mapping_entries': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.register_sim_endpoint = _Endpoint(
            settings={
                'response_type': (Sim,),
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/sims/{sim_id}/register',
                'operation_id': 'register_sim',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'sim_id',
                    'register_sim_request',
                ],
                'required': [
                    'sim_id',
                    'register_sim_request',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'sim_id':
                        (str,),
                    'register_sim_request':
                        (RegisterSimRequest,),
                },
                'attribute_map': {
                    'sim_id': 'sim_id',
                },
                'location_map': {
                    'sim_id': 'path',
                    'register_sim_request': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.remove_arc_sim_credentials_endpoint = _Endpoint(
            settings={
                'response_type': None,
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/sims/{sim_id}/credentials/arc',
                'operation_id': 'remove_arc_sim_credentials',
                'http_method': 'DELETE',
                'servers': None,
            },
            params_map={
                'all': [
                    'sim_id',
                ],
                'required': [
                    'sim_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'sim_id':
                        (str,),
                },
                'attribute_map': {
                    'sim_id': 'sim_id',
                },
                'location_map': {
                    'sim_id': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [],
                'content_type': [],
            },
            api_client=api_client
        )
        self.renew_arc_sim_credentials_endpoint = _Endpoint(
            settings={
                'response_type': (ArcCredentialRenewResponse,),
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/sims/{sim_id}/credentials/arc',
                'operation_id': 'renew_arc_sim_credentials',
                'http_method': 'PUT',
                'servers': None,
            },
            params_map={
                'all': [
                    'sim_id',
                    'arc_credential_renew_request',
                ],
                'required': [
                    'sim_id',
                    'arc_credential_renew_request',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'sim_id':
                        (str,),
                    'arc_credential_renew_request':
                        (ArcCredentialRenewRequest,),
                },
                'attribute_map': {
                    'sim_id': 'sim_id',
                },
                'location_map': {
                    'sim_id': 'path',
                    'arc_credential_renew_request': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.report_sim_local_info_endpoint = _Endpoint(
            settings={
                'response_type': (Subscriber,),
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/sims/{sim_id}/report_local_info',
                'operation_id': 'report_sim_local_info',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'sim_id',
                ],
                'required': [
                    'sim_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'sim_id':
                        (str,),
                },
                'attribute_map': {
                    'sim_id': 'sim_id',
                },
                'location_map': {
                    'sim_id': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.send_sms_to_sim_endpoint = _Endpoint(
            settings={
                'response_type': (SmsForwardingReport,),
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/sims/{sim_id}/send_sms',
                'operation_id': 'send_sms_to_sim',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'sim_id',
                    'sms_forwarding_request',
                ],
                'required': [
                    'sim_id',
                    'sms_forwarding_request',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'sim_id':
                        (str,),
                    'sms_forwarding_request':
                        (SmsForwardingRequest,),
                },
                'attribute_map': {
                    'sim_id': 'sim_id',
                },
                'location_map': {
                    'sim_id': 'path',
                    'sms_forwarding_request': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.set_sim_expiry_time_endpoint = _Endpoint(
            settings={
                'response_type': (Sim,),
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/sims/{sim_id}/set_expiry_time',
                'operation_id': 'set_sim_expiry_time',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'sim_id',
                    'expiry_time',
                ],
                'required': [
                    'sim_id',
                    'expiry_time',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'sim_id':
                        (str,),
                    'expiry_time':
                        (ExpiryTime,),
                },
                'attribute_map': {
                    'sim_id': 'sim_id',
                },
                'location_map': {
                    'sim_id': 'path',
                    'expiry_time': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.set_sim_group_endpoint = _Endpoint(
            settings={
                'response_type': (Sim,),
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/sims/{sim_id}/set_group',
                'operation_id': 'set_sim_group',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'sim_id',
                    'set_group_request',
                ],
                'required': [
                    'sim_id',
                    'set_group_request',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'sim_id':
                        (str,),
                    'set_group_request':
                        (SetGroupRequest,),
                },
                'attribute_map': {
                    'sim_id': 'sim_id',
                },
                'location_map': {
                    'sim_id': 'path',
                    'set_group_request': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.set_sim_imei_lock_endpoint = _Endpoint(
            settings={
                'response_type': (Sim,),
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/sims/{sim_id}/set_imei_lock',
                'operation_id': 'set_sim_imei_lock',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'sim_id',
                    'set_imei_lock_request',
                ],
                'required': [
                    'sim_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'sim_id':
                        (str,),
                    'set_imei_lock_request':
                        (SetImeiLockRequest,),
                },
                'attribute_map': {
                    'sim_id': 'sim_id',
                },
                'location_map': {
                    'sim_id': 'path',
                    'set_imei_lock_request': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )
        self.set_sim_to_standby_endpoint = _Endpoint(
            settings={
                'response_type': (Sim,),
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/sims/{sim_id}/set_to_standby',
                'operation_id': 'set_sim_to_standby',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'sim_id',
                ],
                'required': [
                    'sim_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'sim_id':
                        (str,),
                },
                'attribute_map': {
                    'sim_id': 'sim_id',
                },
                'location_map': {
                    'sim_id': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.stop_sim_packet_capture_session_endpoint = _Endpoint(
            settings={
                'response_type': (PacketCaptureSession,),
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/sims/{sim_id}/packet_capture_sessions/{session_id}/stop',
                'operation_id': 'stop_sim_packet_capture_session',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'sim_id',
                    'session_id',
                ],
                'required': [
                    'sim_id',
                    'session_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'sim_id':
                        (str,),
                    'session_id':
                        (str,),
                },
                'attribute_map': {
                    'sim_id': 'sim_id',
                    'session_id': 'session_id',
                },
                'location_map': {
                    'sim_id': 'path',
                    'session_id': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.suspend_sim_endpoint = _Endpoint(
            settings={
                'response_type': (Sim,),
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/sims/{sim_id}/suspend',
                'operation_id': 'suspend_sim',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'sim_id',
                ],
                'required': [
                    'sim_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'sim_id':
                        (str,),
                },
                'attribute_map': {
                    'sim_id': 'sim_id',
                },
                'location_map': {
                    'sim_id': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.terminate_sim_endpoint = _Endpoint(
            settings={
                'response_type': (Sim,),
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/sims/{sim_id}/terminate',
                'operation_id': 'terminate_sim',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'sim_id',
                ],
                'required': [
                    'sim_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'sim_id':
                        (str,),
                },
                'attribute_map': {
                    'sim_id': 'sim_id',
                },
                'location_map': {
                    'sim_id': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.terminate_subscription_container_endpoint = _Endpoint(
            settings={
                'response_type': None,
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/sims/{sim_id}/profiles/{iccid}/subscribers/{imsi}/terminate',
                'operation_id': 'terminate_subscription_container',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'sim_id',
                    'iccid',
                    'imsi',
                ],
                'required': [
                    'sim_id',
                    'iccid',
                    'imsi',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'sim_id':
                        (str,),
                    'iccid':
                        (str,),
                    'imsi':
                        (str,),
                },
                'attribute_map': {
                    'sim_id': 'sim_id',
                    'iccid': 'iccid',
                    'imsi': 'imsi',
                },
                'location_map': {
                    'sim_id': 'path',
                    'iccid': 'path',
                    'imsi': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [],
                'content_type': [],
            },
            api_client=api_client
        )
        self.unset_sim_expiry_time_endpoint = _Endpoint(
            settings={
                'response_type': None,
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/sims/{sim_id}/unset_expiry_time',
                'operation_id': 'unset_sim_expiry_time',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'sim_id',
                ],
                'required': [
                    'sim_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'sim_id':
                        (str,),
                },
                'attribute_map': {
                    'sim_id': 'sim_id',
                },
                'location_map': {
                    'sim_id': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [],
                'content_type': [],
            },
            api_client=api_client
        )
        self.unset_sim_group_endpoint = _Endpoint(
            settings={
                'response_type': (Sim,),
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/sims/{sim_id}/unset_group',
                'operation_id': 'unset_sim_group',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'sim_id',
                ],
                'required': [
                    'sim_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'sim_id':
                        (str,),
                },
                'attribute_map': {
                    'sim_id': 'sim_id',
                },
                'location_map': {
                    'sim_id': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.unset_sim_imei_lock_endpoint = _Endpoint(
            settings={
                'response_type': (Sim,),
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/sims/{sim_id}/unset_imei_lock',
                'operation_id': 'unset_sim_imei_lock',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'sim_id',
                ],
                'required': [
                    'sim_id',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'sim_id':
                        (str,),
                },
                'attribute_map': {
                    'sim_id': 'sim_id',
                },
                'location_map': {
                    'sim_id': 'path',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [],
            },
            api_client=api_client
        )
        self.update_sim_speed_class_endpoint = _Endpoint(
            settings={
                'response_type': (Sim,),
                'auth': [
                    'api_key',
                    'api_token'
                ],
                'endpoint_path': '/sims/{sim_id}/update_speed_class',
                'operation_id': 'update_sim_speed_class',
                'http_method': 'POST',
                'servers': None,
            },
            params_map={
                'all': [
                    'sim_id',
                    'update_speed_class_request',
                ],
                'required': [
                    'sim_id',
                    'update_speed_class_request',
                ],
                'nullable': [
                ],
                'enum': [
                ],
                'validation': [
                ]
            },
            root_map={
                'validations': {
                },
                'allowed_values': {
                },
                'openapi_types': {
                    'sim_id':
                        (str,),
                    'update_speed_class_request':
                        (UpdateSpeedClassRequest,),
                },
                'attribute_map': {
                    'sim_id': 'sim_id',
                },
                'location_map': {
                    'sim_id': 'path',
                    'update_speed_class_request': 'body',
                },
                'collection_format_map': {
                }
            },
            headers_map={
                'accept': [
                    'application/json'
                ],
                'content_type': [
                    'application/json'
                ]
            },
            api_client=api_client
        )

    def activate_sim(
        self,
        sim_id,
        **kwargs
    ):
        """Activate SIM.  # noqa: E501

        Change status of specified SIM to active.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.activate_sim(sim_id, async_req=True)
        >>> result = thread.get()

        Args:
            sim_id (str): SIM ID of the target SIM.

        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:
            Sim
                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['sim_id'] = \
            sim_id
        return self.activate_sim_endpoint.call_with_http_info(**kwargs)

    def add_subscription(
        self,
        sim_id,
        iccid,
        **kwargs
    ):
        """Adds a new subscription container to a SIM profile  # noqa: E501

        This API is used to trigger the OTA update of a new subscription container to a SIM profile.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.add_subscription(sim_id, iccid, async_req=True)
        >>> result = thread.get()

        Args:
            sim_id (str): Id of the target SIM
            iccid (str): Iccid of the target profile

        Keyword Args:
            inline_object3 (InlineObject3): [optional]
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/float/tuple): timeout setting for this request. If
                one number provided, it will be total request timeout. It can also
                be a pair (tuple) of (connection, read) timeouts.
                Default is None.
            _check_input_type (bool): specifies if type checking
                should be done one the data sent to the server.
                Default is True.
            _check_return_type (bool): specifies if type checking
                should be done one the data received from the server.
                Default is True.
            _spec_property_naming (bool): True if the variable names in the input data
                are serialized names, as specified in the OpenAPI document.
                False if the variable names in the input data
                are pythonic names, e.g. snake case (default)
            _content_type (str/None): force body content-type.
                Default is None and content-type will be predicted by allowed
                content-types and body.
            _host_index (int/None): specifies the index of the server
                that we want to use.
                Default is read from the configuration.
            async_req (bool): execute request asynchronously

        Returns:
            SimProfile
                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['sim_id'] = \
            sim_id
        kwargs['iccid'] = \
            iccid
        return self.add_subscription_endpoint.call_with_http_info(**kwargs)

    def attach_arc_sim_credentials(
        self,
        sim_id,
        arc_credential_attach_request,
        **kwargs
    ):
        """(DEPRECATED) Attach the credentials for Arc to a SIM.  # noqa: E501

        (DEPRECATED) Use this API to attach a set of credentials to a SIM. Please use `renewArcSimCredentials` API instead.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.attach_arc_sim_credentials(sim_id, arc_credential_attach_request, async_req=True)
        >>> result = thread.get()

        Args:
            sim_id (str): SIM ID of the target SIM.
            arc_credential_attach_request (ArcCredentialAttachRequest): Arc credential attach 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:
            ArcCredentialAttachResponse
                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['sim_id'] = \
            sim_id
        kwargs['arc_credential_attach_request'] = \
            arc_credential_attach_request
        return self.attach_arc_sim_credentials_endpoint.call_with_http_info(**kwargs)

    def cancel_subscription_container_download(
        self,
        sim_id,
        iccid,
        imsi,
        **kwargs
    ):
        """Cancel subscription download to subscription container  # noqa: E501

        Cancel the download of subscription before it gets downloaded to the SIM. The condition is that the status of the subscription is still `shipped`  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.cancel_subscription_container_download(sim_id, iccid, imsi, async_req=True)
        >>> result = thread.get()

        Args:
            sim_id (str): SIM ID of the target subscription container.
            iccid (str): ICCID of the target subscription container.
            imsi (str): IMSI of the target subscription container.

        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:
            SubscriptionContainerStatus
                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['sim_id'] = \
            sim_id
        kwargs['iccid'] = \
            iccid
        kwargs['imsi'] = \
            imsi
        return self.cancel_subscription_container_download_endpoint.call_with_http_info(**kwargs)

    def create_arc_session(
        self,
        sim_id,
        **kwargs
    ):
        """Re-create an Arc session.  # noqa: E501

        Use this API to re-activate a session for a virtual SIM.  # 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_arc_session(sim_id, async_req=True)
        >>> result = thread.get()

        Args:
            sim_id (str): SIM ID of the target SIM.

        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:
            ArcSessionCreateResponse
                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['sim_id'] = \
            sim_id
        return self.create_arc_session_endpoint.call_with_http_info(**kwargs)

    def create_sim(
        self,
        create_sim_request,
        **kwargs
    ):
        """Create a SIM.  # noqa: E501

        Creates a SIM for example for use with Arc service.  # 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_sim(create_sim_request, async_req=True)
        >>> result = thread.get()

        Args:
            create_sim_request (CreateSimRequest): A SIM creation 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:
            Sim
                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['create_sim_request'] = \
            create_sim_request
        return self.create_sim_endpoint.call_with_http_info(**kwargs)

    def create_sim_packet_capture_session(
        self,
        sim_id,
        packet_capture_session_request,
        **kwargs
    ):
        """Create Packet Capture Session  # noqa: E501

        Create a packet capture session associated with the SIM  # 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_sim_packet_capture_session(sim_id, packet_capture_session_request, async_req=True)
        >>> result = thread.get()

        Args:
            sim_id (str): The SIM ID for which a packet capture session is created
            packet_capture_session_request (PacketCaptureSessionRequest): A packet capture session 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:
            PacketCaptureSession
                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['sim_id'] = \
            sim_id
        kwargs['packet_capture_session_request'] = \
            packet_capture_session_request
        return self.create_sim_packet_capture_session_endpoint.call_with_http_info(**kwargs)

    def deactivate_sim(
        self,
        sim_id,
        **kwargs
    ):
        """Deactivate SIM.  # noqa: E501

        Change status of specified SIM to inactive.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.deactivate_sim(sim_id, async_req=True)
        >>> result = thread.get()

        Args:
            sim_id (str): SIM ID of the target SIM.

        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:
            Sim
                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['sim_id'] = \
            sim_id
        return self.deactivate_sim_endpoint.call_with_http_info(**kwargs)

    def delete_sim_packet_capture_session(
        self,
        sim_id,
        session_id,
        **kwargs
    ):
        """Delete Packet Capture Session  # noqa: E501

        Delete a packet capture session associated with the SIM  # 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_sim_packet_capture_session(sim_id, session_id, async_req=True)
        >>> result = thread.get()

        Args:
            sim_id (str): SIM ID
            session_id (str): Packet capture session 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:
            PacketCaptureSession
                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['sim_id'] = \
            sim_id
        kwargs['session_id'] = \
            session_id
        return self.delete_sim_packet_capture_session_endpoint.call_with_http_info(**kwargs)

    def delete_sim_session(
        self,
        sim_id,
        **kwargs
    ):
        """Delete Session  # noqa: E501

        Deletes session for the specified SIM.  # 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_sim_session(sim_id, async_req=True)
        >>> result = thread.get()

        Args:
            sim_id (str): SIM ID of the target SIM.

        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:
            Sim
                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['sim_id'] = \
            sim_id
        return self.delete_sim_session_endpoint.call_with_http_info(**kwargs)

    def delete_sim_tag(
        self,
        sim_id,
        tag_name,
        **kwargs
    ):
        """Delete SIM tag.  # noqa: E501

        Deletes a tag from the specified SIM.  # 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_sim_tag(sim_id, tag_name, async_req=True)
        >>> result = thread.get()

        Args:
            sim_id (str): Sim Id of the target SIM.
            tag_name (str): Tag name to be deleted. (This will be part of a URL path, so it needs to be percent-encoded. In JavaScript, specify the name after it has been encoded using encodeURIComponent().)

        Keyword Args:
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/float/tuple): timeout setting for this request. If
                one number provided, it will be total request timeout. It can also
                be a pair (tuple) of (connection, read) timeouts.
                Default is None.
            _check_input_type (bool): specifies if type checking
                should be done one the data sent to the server.
                Default is True.
            _check_return_type (bool): specifies if type checking
                should be done one the data received from the server.
                Default is True.
            _spec_property_naming (bool): True if the variable names in the input data
                are serialized names, as specified in the OpenAPI document.
                False if the variable names in the input data
                are pythonic names, e.g. snake case (default)
            _content_type (str/None): force body content-type.
                Default is None and content-type will be predicted by allowed
                content-types and body.
            _host_index (int/None): specifies the index of the server
                that we want to use.
                Default is read from the configuration.
            async_req (bool): execute request asynchronously

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

    def delete_subscription_container_country_mapping_entry(
        self,
        sim_id,
        iccid,
        mcc,
        **kwargs
    ):
        """Delete subscription container mapping entries  # noqa: E501

        Delete subscription container country mapping entries  # 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_subscription_container_country_mapping_entry(sim_id, iccid, mcc, async_req=True)
        >>> result = thread.get()

        Args:
            sim_id (str): SIM ID of the target SIM.
            iccid (str): Iccid of the target profile
            mcc (str): mobile country code

        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:
            SubscriptionContainerStatus
                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['sim_id'] = \
            sim_id
        kwargs['iccid'] = \
            iccid
        kwargs['mcc'] = \
            mcc
        return self.delete_subscription_container_country_mapping_entry_endpoint.call_with_http_info(**kwargs)

    def disable_sim_termination(
        self,
        sim_id,
        **kwargs
    ):
        """Disable termination of the SIM.  # noqa: E501

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

        >>> thread = api.disable_sim_termination(sim_id, async_req=True)
        >>> result = thread.get()

        Args:
            sim_id (str): SIM ID of the target SIM.

        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:
            Sim
                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['sim_id'] = \
            sim_id
        return self.disable_sim_termination_endpoint.call_with_http_info(**kwargs)

    def downlink_ping_to_user_equipment(
        self,
        sim_id,
        downlink_ping_request,
        **kwargs
    ):
        """Send ping requests to a SIM.  # noqa: E501

        Send ICMP ping requests to a SIM.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.downlink_ping_to_user_equipment(sim_id, downlink_ping_request, async_req=True)
        >>> result = thread.get()

        Args:
            sim_id (str): SIM ID of the target SIM.
            downlink_ping_request (DownlinkPingRequest): ping options

        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:
            DownlinkPingResponse
                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['sim_id'] = \
            sim_id
        kwargs['downlink_ping_request'] = \
            downlink_ping_request
        return self.downlink_ping_to_user_equipment_endpoint.call_with_http_info(**kwargs)

    def enable_sim_termination(
        self,
        sim_id,
        **kwargs
    ):
        """Enable termination of the SIM.  # noqa: E501

        Enables termination of specified SIM.  # 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_sim_termination(sim_id, async_req=True)
        >>> result = thread.get()

        Args:
            sim_id (str): SIM ID of the target SIM.

        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:
            Sim
                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['sim_id'] = \
            sim_id
        return self.enable_sim_termination_endpoint.call_with_http_info(**kwargs)

    def enable_subscription_container(
        self,
        sim_id,
        iccid,
        container_id,
        **kwargs
    ):
        """Enables a subscription container.  # noqa: E501

        Causes the identified container to become the active one on the Sim.  # 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_subscription_container(sim_id, iccid, container_id, async_req=True)
        >>> result = thread.get()

        Args:
            sim_id (str): SIM ID of the target SIM.
            iccid (str): Iccid of the target profile
            container_id (str): Identifier of the target container

        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:
            SubscriptionContainerStatus
                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['sim_id'] = \
            sim_id
        kwargs['iccid'] = \
            iccid
        kwargs['container_id'] = \
            container_id
        return self.enable_subscription_container_endpoint.call_with_http_info(**kwargs)

    def get_data_from_sim(
        self,
        sim_id,
        **kwargs
    ):
        """Get data sent from a SIM.  # noqa: E501

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

        >>> thread = api.get_data_from_sim(sim_id, async_req=True)
        >>> result = thread.get()

        Args:
            sim_id (str): Sim Id of the target SIM.

        Keyword Args:
            _from (int): Start time for the data entries search range (unixtime in milliseconds).. [optional]
            to (int): End time for the data entries search range (unixtime in milliseconds).. [optional]
            sort (str): Sort order of the data entries. Either descending (latest data entry first) or ascending (oldest data entry first).. [optional] if omitted the server will use the default value of "desc"
            limit (int): Maximum number of data entries to retrieve.. [optional]
            last_evaluated_key (str): The value of `time` in the last log entry retrieved in the previous page. By specifying this parameter, you can continue to retrieve the list from the next page onward.. [optional]
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/float/tuple): timeout setting for this request. If
                one number provided, it will be total request timeout. It can also
                be a pair (tuple) of (connection, read) timeouts.
                Default is None.
            _check_input_type (bool): specifies if type checking
                should be done one the data sent to the server.
                Default is True.
            _check_return_type (bool): specifies if type checking
                should be done one the data received from the server.
                Default is True.
            _spec_property_naming (bool): True if the variable names in the input data
                are serialized names, as specified in the OpenAPI document.
                False if the variable names in the input data
                are pythonic names, e.g. snake case (default)
            _content_type (str/None): force body content-type.
                Default is None and content-type will be predicted by allowed
                content-types and body.
            _host_index (int/None): specifies the index of the server
                that we want to use.
                Default is read from the configuration.
            async_req (bool): execute request asynchronously

        Returns:
            [DataEntry]
                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['sim_id'] = \
            sim_id
        return self.get_data_from_sim_endpoint.call_with_http_info(**kwargs)

    def get_sim(
        self,
        sim_id,
        **kwargs
    ):
        """Get a SIM identified by sim_id  # noqa: E501

        Obtain a SIM record identified by the sim_id  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.get_sim(sim_id, async_req=True)
        >>> result = thread.get()

        Args:
            sim_id (str): Id of the target SIM

        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:
            Sim
                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['sim_id'] = \
            sim_id
        return self.get_sim_endpoint.call_with_http_info(**kwargs)

    def get_sim_packet_capture_session(
        self,
        sim_id,
        session_id,
        **kwargs
    ):
        """Get Packet Capture Session  # noqa: E501

        Get a packet capture sessions associated the SIM  # 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_sim_packet_capture_session(sim_id, session_id, async_req=True)
        >>> result = thread.get()

        Args:
            sim_id (str): SIM ID
            session_id (str): Packet capture session 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:
            PacketCaptureSession
                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['sim_id'] = \
            sim_id
        kwargs['session_id'] = \
            session_id
        return self.get_sim_packet_capture_session_endpoint.call_with_http_info(**kwargs)

    def list_sim_packet_capture_sessions(
        self,
        sim_id,
        **kwargs
    ):
        """List Packet Capture Sessions  # noqa: E501

        List packet capture sessions associated with the SIM  # 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_sim_packet_capture_sessions(sim_id, async_req=True)
        >>> result = thread.get()

        Args:
            sim_id (str): SIM ID

        Keyword Args:
            last_evaluated_key (str): ID of the last packet capture session in the previous page. [optional]
            limit (int): Max number of results in a response. [optional] if omitted the server will use the default value of 10
            _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:
            [PacketCaptureSession]
                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['sim_id'] = \
            sim_id
        return self.list_sim_packet_capture_sessions_endpoint.call_with_http_info(**kwargs)

    def list_sim_session_events(
        self,
        sim_id,
        **kwargs
    ):
        """List Session Events.  # noqa: E501

        Returns the history of session creation, change, and deletion events occurred on the target SIM in the last 14 days. If the total number of events does not fit in one page, a URL for accessing the next page is returned in the `Link` header of the response.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.list_sim_session_events(sim_id, async_req=True)
        >>> result = thread.get()

        Args:
            sim_id (str): SIM ID of the target SIM.

        Keyword Args:
            _from (int): Start time for the events search range (unixtime).. [optional]
            to (int): End time for the events search range (unixtime).. [optional]
            limit (int): Maximum number of events to retrieve.. [optional]
            last_evaluated_key (str): The time stamp of the last event retrieved on the current page. By specifying this parameter, you can continue to retrieve the list from the next event onward.. [optional]
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/float/tuple): timeout setting for this request. If
                one number provided, it will be total request timeout. It can also
                be a pair (tuple) of (connection, read) timeouts.
                Default is None.
            _check_input_type (bool): specifies if type checking
                should be done one the data sent to the server.
                Default is True.
            _check_return_type (bool): specifies if type checking
                should be done one the data received from the server.
                Default is True.
            _spec_property_naming (bool): True if the variable names in the input data
                are serialized names, as specified in the OpenAPI document.
                False if the variable names in the input data
                are pythonic names, e.g. snake case (default)
            _content_type (str/None): force body content-type.
                Default is None and content-type will be predicted by allowed
                content-types and body.
            _host_index (int/None): specifies the index of the server
                that we want to use.
                Default is read from the configuration.
            async_req (bool): execute request asynchronously

        Returns:
            [SessionEvent]
                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['sim_id'] = \
            sim_id
        return self.list_sim_session_events_endpoint.call_with_http_info(**kwargs)

    def list_sims(
        self,
        **kwargs
    ):
        """List SIMs.  # noqa: E501

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

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


        Keyword Args:
            limit (int): Maximum number of SIMs to retrieve. Setting a limit does not guarantee the number of sims returned in the response (i.e. the response may contain fewer sims than the specified limit).. [optional]
            last_evaluated_key (str): The ID of the last SIM retrieved on the current page. By specifying this parameter, you can continue to retrieve the list from the next SIM onward.. [optional]
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/float/tuple): timeout setting for this request. If
                one number provided, it will be total request timeout. It can also
                be a pair (tuple) of (connection, read) timeouts.
                Default is None.
            _check_input_type (bool): specifies if type checking
                should be done one the data sent to the server.
                Default is True.
            _check_return_type (bool): specifies if type checking
                should be done one the data received from the server.
                Default is True.
            _spec_property_naming (bool): True if the variable names in the input data
                are serialized names, as specified in the OpenAPI document.
                False if the variable names in the input data
                are pythonic names, e.g. snake case (default)
            _content_type (str/None): force body content-type.
                Default is None and content-type will be predicted by allowed
                content-types and body.
            _host_index (int/None): specifies the index of the server
                that we want to use.
                Default is read from the configuration.
            async_req (bool): execute request asynchronously

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

    def list_subscription_containers(
        self,
        sim_id,
        iccid,
        **kwargs
    ):
        """Get subscription container status.  # noqa: E501

        Returns a schema listing subscription containers and containing a map of PLMN codes to subscription containers  # 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_subscription_containers(sim_id, iccid, async_req=True)
        >>> result = thread.get()

        Args:
            sim_id (str): Sim Id of the target SIM.
            iccid (str): Iccid of the target profile

        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:
            SubscriptionContainerStatus
                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['sim_id'] = \
            sim_id
        kwargs['iccid'] = \
            iccid
        return self.list_subscription_containers_endpoint.call_with_http_info(**kwargs)

    def put_sim_tags(
        self,
        sim_id,
        tag_update_request,
        **kwargs
    ):
        """Bulk insert or update SIM tags.  # noqa: E501

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

        >>> thread = api.put_sim_tags(sim_id, tag_update_request, async_req=True)
        >>> result = thread.get()

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

        Keyword Args:
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/float/tuple): timeout setting for this request. If
                one number provided, it will be total request timeout. It can also
                be a pair (tuple) of (connection, read) timeouts.
                Default is None.
            _check_input_type (bool): specifies if type checking
                should be done one the data sent to the server.
                Default is True.
            _check_return_type (bool): specifies if type checking
                should be done one the data received from the server.
                Default is True.
            _spec_property_naming (bool): True if the variable names in the input data
                are serialized names, as specified in the OpenAPI document.
                False if the variable names in the input data
                are pythonic names, e.g. snake case (default)
            _content_type (str/None): force body content-type.
                Default is None and content-type will be predicted by allowed
                content-types and body.
            _host_index (int/None): specifies the index of the server
                that we want to use.
                Default is read from the configuration.
            async_req (bool): execute request asynchronously

        Returns:
            Sim
                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['sim_id'] = \
            sim_id
        kwargs['tag_update_request'] = \
            tag_update_request
        return self.put_sim_tags_endpoint.call_with_http_info(**kwargs)

    def put_subscription_container_country_mapping_entries(
        self,
        sim_id,
        iccid,
        mapping_entries,
        **kwargs
    ):
        """Updates subscription container country mapping entries.  # noqa: E501

        Inserts/updates Country (and optionally network) to subscription container mapping entries in the mapping table.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.put_subscription_container_country_mapping_entries(sim_id, iccid, mapping_entries, async_req=True)
        >>> result = thread.get()

        Args:
            sim_id (str): SIM ID of the target SIM.
            iccid (str): Iccid of the target profile
            mapping_entries (MappingEntries): collection of country (and optionally network) to subscription container mapping entries

        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:
            SubscriptionContainerStatus
                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['sim_id'] = \
            sim_id
        kwargs['iccid'] = \
            iccid
        kwargs['mapping_entries'] = \
            mapping_entries
        return self.put_subscription_container_country_mapping_entries_endpoint.call_with_http_info(**kwargs)

    def register_sim(
        self,
        sim_id,
        register_sim_request,
        **kwargs
    ):
        """Register SIM.  # noqa: E501

        Registers a SIM to an operator.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.register_sim(sim_id, register_sim_request, async_req=True)
        >>> result = thread.get()

        Args:
            sim_id (str): SIM ID of the target SIM.
            register_sim_request (RegisterSimRequest): A SIM registration 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:
            Sim
                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['sim_id'] = \
            sim_id
        kwargs['register_sim_request'] = \
            register_sim_request
        return self.register_sim_endpoint.call_with_http_info(**kwargs)

    def remove_arc_sim_credentials(
        self,
        sim_id,
        **kwargs
    ):
        """(DEPRECATED) Remove the credentials for Arc from a SIM.  # noqa: E501

        (DEPRECATED) Use this API to remove the set of credentials for Arc from the specified SIM. Please do not use this API.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.remove_arc_sim_credentials(sim_id, async_req=True)
        >>> result = thread.get()

        Args:
            sim_id (str): SIM ID of the target SIM.

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

    def renew_arc_sim_credentials(
        self,
        sim_id,
        arc_credential_renew_request,
        **kwargs
    ):
        """Renew the credentials for Arc to a SIM.  # noqa: E501

        Use this API to attach a set of credentials to a SIM and re-initialize a session at once.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.renew_arc_sim_credentials(sim_id, arc_credential_renew_request, async_req=True)
        >>> result = thread.get()

        Args:
            sim_id (str): SIM ID of the target SIM.
            arc_credential_renew_request (ArcCredentialRenewRequest): Arc credential attach 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:
            ArcCredentialRenewResponse
                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['sim_id'] = \
            sim_id
        kwargs['arc_credential_renew_request'] = \
            arc_credential_renew_request
        return self.renew_arc_sim_credentials_endpoint.call_with_http_info(**kwargs)

    def report_sim_local_info(
        self,
        sim_id,
        **kwargs
    ):
        """Triggers SIM to report SIM local info.  # noqa: E501

        Triggers SIM to report SIM local info.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.report_sim_local_info(sim_id, async_req=True)
        >>> result = thread.get()

        Args:
            sim_id (str): SIM ID of the target SIM.

        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:
            Subscriber
                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['sim_id'] = \
            sim_id
        return self.report_sim_local_info_endpoint.call_with_http_info(**kwargs)

    def send_sms_to_sim(
        self,
        sim_id,
        sms_forwarding_request,
        **kwargs
    ):
        """Send SMS to SIM  # noqa: E501

        Send SMS to the specified SIM.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.send_sms_to_sim(sim_id, sms_forwarding_request, async_req=True)
        >>> result = thread.get()

        Args:
            sim_id (str): SIM ID of the target SIM.
            sms_forwarding_request (SmsForwardingRequest): SMS forwarding request that contains message body and its encoding type.

        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:
            SmsForwardingReport
                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['sim_id'] = \
            sim_id
        kwargs['sms_forwarding_request'] = \
            sms_forwarding_request
        return self.send_sms_to_sim_endpoint.call_with_http_info(**kwargs)

    def set_sim_expiry_time(
        self,
        sim_id,
        expiry_time,
        **kwargs
    ):
        """Update expiry time of SIM.  # noqa: E501

        Updates expiry time of the specified SIM.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.set_sim_expiry_time(sim_id, expiry_time, async_req=True)
        >>> result = thread.get()

        Args:
            sim_id (str): SIM ID of the target SIM.
            expiry_time (ExpiryTime): Expiry time after the update (unixtime: in milliseconds).

        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:
            Sim
                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['sim_id'] = \
            sim_id
        kwargs['expiry_time'] = \
            expiry_time
        return self.set_sim_expiry_time_endpoint.call_with_http_info(**kwargs)

    def set_sim_group(
        self,
        sim_id,
        set_group_request,
        **kwargs
    ):
        """Set Group id of a SIM.  # noqa: E501

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

        >>> thread = api.set_sim_group(sim_id, set_group_request, async_req=True)
        >>> result = thread.get()

        Args:
            sim_id (str): SIM ID of the target SIM.
            set_group_request (SetGroupRequest): Group (may include ID only).

        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:
            Sim
                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['sim_id'] = \
            sim_id
        kwargs['set_group_request'] = \
            set_group_request
        return self.set_sim_group_endpoint.call_with_http_info(**kwargs)

    def set_sim_imei_lock(
        self,
        sim_id,
        **kwargs
    ):
        """Set IMEI lock configuration for the SIM.  # noqa: E501

        Set IMEI that the SIM should be locked to.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.set_sim_imei_lock(sim_id, async_req=True)
        >>> result = thread.get()

        Args:
            sim_id (str): SIM ID of the target SIM.

        Keyword Args:
            set_imei_lock_request (SetImeiLockRequest): IMEI lock configuration for the SIM. (IMEI can be left blank for locking to the current IMEI of an online SIM.). [optional]
            _return_http_data_only (bool): response data without head status
                code and headers. Default is True.
            _preload_content (bool): if False, the urllib3.HTTPResponse object
                will be returned without reading/decoding response data.
                Default is True.
            _request_timeout (int/float/tuple): timeout setting for this request. If
                one number provided, it will be total request timeout. It can also
                be a pair (tuple) of (connection, read) timeouts.
                Default is None.
            _check_input_type (bool): specifies if type checking
                should be done one the data sent to the server.
                Default is True.
            _check_return_type (bool): specifies if type checking
                should be done one the data received from the server.
                Default is True.
            _spec_property_naming (bool): True if the variable names in the input data
                are serialized names, as specified in the OpenAPI document.
                False if the variable names in the input data
                are pythonic names, e.g. snake case (default)
            _content_type (str/None): force body content-type.
                Default is None and content-type will be predicted by allowed
                content-types and body.
            _host_index (int/None): specifies the index of the server
                that we want to use.
                Default is read from the configuration.
            async_req (bool): execute request asynchronously

        Returns:
            Sim
                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['sim_id'] = \
            sim_id
        return self.set_sim_imei_lock_endpoint.call_with_http_info(**kwargs)

    def set_sim_to_standby(
        self,
        sim_id,
        **kwargs
    ):
        """Set SIM to standby mode.  # noqa: E501

        Set the specified SIM to standby mode.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.set_sim_to_standby(sim_id, async_req=True)
        >>> result = thread.get()

        Args:
            sim_id (str): SIM ID of the target SIM.

        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:
            Sim
                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['sim_id'] = \
            sim_id
        return self.set_sim_to_standby_endpoint.call_with_http_info(**kwargs)

    def stop_sim_packet_capture_session(
        self,
        sim_id,
        session_id,
        **kwargs
    ):
        """Stop SIM Packet Capture Session  # noqa: E501

        Stop a packet capture session associated with the SIM  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.stop_sim_packet_capture_session(sim_id, session_id, async_req=True)
        >>> result = thread.get()

        Args:
            sim_id (str): SIM ID
            session_id (str): Packet capture session 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:
            PacketCaptureSession
                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['sim_id'] = \
            sim_id
        kwargs['session_id'] = \
            session_id
        return self.stop_sim_packet_capture_session_endpoint.call_with_http_info(**kwargs)

    def suspend_sim(
        self,
        sim_id,
        **kwargs
    ):
        """Suspend SIM.  # noqa: E501

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

        >>> thread = api.suspend_sim(sim_id, async_req=True)
        >>> result = thread.get()

        Args:
            sim_id (str): SIM ID of the target SIM.

        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:
            Sim
                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['sim_id'] = \
            sim_id
        return self.suspend_sim_endpoint.call_with_http_info(**kwargs)

    def terminate_sim(
        self,
        sim_id,
        **kwargs
    ):
        """Terminate SIM.  # noqa: E501

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

        >>> thread = api.terminate_sim(sim_id, async_req=True)
        >>> result = thread.get()

        Args:
            sim_id (str): SIM ID of the target SIM.

        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:
            Sim
                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['sim_id'] = \
            sim_id
        return self.terminate_sim_endpoint.call_with_http_info(**kwargs)

    def terminate_subscription_container(
        self,
        sim_id,
        iccid,
        imsi,
        **kwargs
    ):
        """Terminate subscription container  # noqa: E501

        Terminate subscription container. Currently this API supports only for virtual subscribers for SORACOM Arc service.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.terminate_subscription_container(sim_id, iccid, imsi, async_req=True)
        >>> result = thread.get()

        Args:
            sim_id (str): SIM ID of the target subscription container.
            iccid (str): ICCID of the target subscription container.
            imsi (str): IMSI of the target subscription container.

        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['sim_id'] = \
            sim_id
        kwargs['iccid'] = \
            iccid
        kwargs['imsi'] = \
            imsi
        return self.terminate_subscription_container_endpoint.call_with_http_info(**kwargs)

    def unset_sim_expiry_time(
        self,
        sim_id,
        **kwargs
    ):
        """Delete expiry time of the SIM.  # noqa: E501

        Deletes expiry time of specified SIM and changes it to indefinite.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.unset_sim_expiry_time(sim_id, async_req=True)
        >>> result = thread.get()

        Args:
            sim_id (str): SIM ID of the target SIM.

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

    def unset_sim_group(
        self,
        sim_id,
        **kwargs
    ):
        """Unset Group to SIM.  # noqa: E501

        Removes the group configuration from the specified SIM.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.unset_sim_group(sim_id, async_req=True)
        >>> result = thread.get()

        Args:
            sim_id (str): SIM ID of the target SIM.

        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:
            Sim
                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['sim_id'] = \
            sim_id
        return self.unset_sim_group_endpoint.call_with_http_info(**kwargs)

    def unset_sim_imei_lock(
        self,
        sim_id,
        **kwargs
    ):
        """Unset IMEI lock configuration for SIM.  # noqa: E501

        Remove any existing IMEI lock configuration for the SIM.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True

        >>> thread = api.unset_sim_imei_lock(sim_id, async_req=True)
        >>> result = thread.get()

        Args:
            sim_id (str): Sim Id of the target SIM.

        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:
            Sim
                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['sim_id'] = \
            sim_id
        return self.unset_sim_imei_lock_endpoint.call_with_http_info(**kwargs)

    def update_sim_speed_class(
        self,
        sim_id,
        update_speed_class_request,
        **kwargs
    ):
        """Update SIM speed class.  # noqa: E501

        Changes the speed class of the specified SIM.  # 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_sim_speed_class(sim_id, update_speed_class_request, async_req=True)
        >>> result = thread.get()

        Args:
            sim_id (str): SIM ID of the target SIM.
            update_speed_class_request (UpdateSpeedClassRequest): speed_class

        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:
            Sim
                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['sim_id'] = \
            sim_id
        kwargs['update_speed_class_request'] = \
            update_speed_class_request
        return self.update_sim_speed_class_endpoint.call_with_http_info(**kwargs)

