Module mailslurp_client.api.device_previews_controller_api

MailSlurp API

MailSlurp is an API for sending and receiving emails and SMS from dynamically allocated email addresses and phone numbers. It's designed for developers and QA teams to test applications, process inbound emails, send templated notifications, attachments, and more. ## Resources - Homepage - Get an API KEY - Generated SDK Clients - Examples repository # noqa: E501

The version of the OpenAPI document: 6.5.2 Contact: contact@mailslurp.dev Generated by: https://openapi-generator.tech

Classes

class DevicePreviewsControllerApi (api_client=None)

NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech

Do not edit the class manually.

Expand source code

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

    Do not edit the class manually.
    """

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

    def cancel_device_preview_run(self, run_id, **kwargs):  # noqa: E501
        """Cancel a running device preview run  # 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_device_preview_run(run_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str run_id: (required)
        :param CancelDevicePreviewRunOptions cancel_device_preview_run_options:
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: CancelDevicePreviewRunResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.cancel_device_preview_run_with_http_info(run_id, **kwargs)  # noqa: E501

    def cancel_device_preview_run_with_http_info(self, run_id, **kwargs):  # noqa: E501
        """Cancel a running device preview run  # 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_device_preview_run_with_http_info(run_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str run_id: (required)
        :param CancelDevicePreviewRunOptions cancel_device_preview_run_options:
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(CancelDevicePreviewRunResult, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'run_id',
            'cancel_device_preview_run_options'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

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

        collection_formats = {}

        path_params = {}
        if 'run_id' in local_var_params:
            path_params['runId'] = local_var_params['run_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

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

        return self.api_client.call_api(
            '/emails/device-previews/{runId}/cancel', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CancelDevicePreviewRunResult',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def create_device_preview_feedback(self, create_device_preview_feedback_options, **kwargs):  # noqa: E501
        """Create device preview feedback  # 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_device_preview_feedback(create_device_preview_feedback_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param CreateDevicePreviewFeedbackOptions create_device_preview_feedback_options: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: DevicePreviewFeedbackDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.create_device_preview_feedback_with_http_info(create_device_preview_feedback_options, **kwargs)  # noqa: E501

    def create_device_preview_feedback_with_http_info(self, create_device_preview_feedback_options, **kwargs):  # noqa: E501
        """Create device preview feedback  # 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_device_preview_feedback_with_http_info(create_device_preview_feedback_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param CreateDevicePreviewFeedbackOptions create_device_preview_feedback_options: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(DevicePreviewFeedbackDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'create_device_preview_feedback_options'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

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

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

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

        return self.api_client.call_api(
            '/emails/device-previews/feedback', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DevicePreviewFeedbackDto',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def create_device_preview_folder(self, create_device_preview_folder_options, **kwargs):  # noqa: E501
        """Create a device preview folder  # 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_device_preview_folder(create_device_preview_folder_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param CreateDevicePreviewFolderOptions create_device_preview_folder_options: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: DevicePreviewFolderDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.create_device_preview_folder_with_http_info(create_device_preview_folder_options, **kwargs)  # noqa: E501

    def create_device_preview_folder_with_http_info(self, create_device_preview_folder_options, **kwargs):  # noqa: E501
        """Create a device preview folder  # 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_device_preview_folder_with_http_info(create_device_preview_folder_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param CreateDevicePreviewFolderOptions create_device_preview_folder_options: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(DevicePreviewFolderDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'create_device_preview_folder_options'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

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

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

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

        return self.api_client.call_api(
            '/emails/device-previews/folders', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DevicePreviewFolderDto',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def create_device_preview_import_address(self, **kwargs):  # noqa: E501
        """Create a temporary email address for device preview import  # 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_device_preview_import_address(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param CreateDevicePreviewIngestAddressOptions create_device_preview_ingest_address_options:
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: DevicePreviewIngestAddressDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.create_device_preview_import_address_with_http_info(**kwargs)  # noqa: E501

    def create_device_preview_import_address_with_http_info(self, **kwargs):  # noqa: E501
        """Create a temporary email address for device preview import  # 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_device_preview_import_address_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param CreateDevicePreviewIngestAddressOptions create_device_preview_ingest_address_options:
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(DevicePreviewIngestAddressDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'create_device_preview_ingest_address_options'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

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

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

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

        return self.api_client.call_api(
            '/emails/device-previews/import-addresses', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DevicePreviewIngestAddressDto',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def create_device_preview_profile(self, create_device_preview_profile_options, **kwargs):  # noqa: E501
        """Create a device preview 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.create_device_preview_profile(create_device_preview_profile_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param CreateDevicePreviewProfileOptions create_device_preview_profile_options: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: DevicePreviewProfileDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.create_device_preview_profile_with_http_info(create_device_preview_profile_options, **kwargs)  # noqa: E501

    def create_device_preview_profile_with_http_info(self, create_device_preview_profile_options, **kwargs):  # noqa: E501
        """Create a device preview 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.create_device_preview_profile_with_http_info(create_device_preview_profile_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param CreateDevicePreviewProfileOptions create_device_preview_profile_options: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(DevicePreviewProfileDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'create_device_preview_profile_options'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

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

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

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

        return self.api_client.call_api(
            '/emails/device-previews/profiles', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DevicePreviewProfileDto',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def create_device_preview_run(self, email_id, **kwargs):  # noqa: E501
        """Create a new device preview run for an email  # 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_device_preview_run(email_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: (required)
        :param CreateDevicePreviewOptions create_device_preview_options:
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: CreateDevicePreviewRunResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.create_device_preview_run_with_http_info(email_id, **kwargs)  # noqa: E501

    def create_device_preview_run_with_http_info(self, email_id, **kwargs):  # noqa: E501
        """Create a new device preview run for an email  # 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_device_preview_run_with_http_info(email_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: (required)
        :param CreateDevicePreviewOptions create_device_preview_options:
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(CreateDevicePreviewRunResult, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'email_id',
            'create_device_preview_options'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

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

        collection_formats = {}

        path_params = {}
        if 'email_id' in local_var_params:
            path_params['emailId'] = local_var_params['email_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

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

        return self.api_client.call_api(
            '/emails/{emailId}/device-previews', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CreateDevicePreviewRunResult',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def create_device_preview_run_from_file(self, file, **kwargs):  # noqa: E501
        """Create a device preview run from an HTML, EML, or ZIP file  # noqa: E501

        Uploads an HTML or RFC822 EML file, or a ZIP archive containing exactly one HTML or EML file. ZIP uploads are bounded by entry count, expanded size, and compression ratio.  # 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_device_preview_run_from_file(file, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param file file: An .html, .htm, or .eml file, or a .zip archive containing exactly one supported file. (required)
        :param str subject:
        :param str _from:
        :param str to:
        :param str source_alias:
        :param str external_id:
        :param list[str] providers: Legacy web-provider keys to render.
        :param bool all_targets: Render every currently configured target.
        :param list[str] targets: Device preview target keys to render.
        :param bool email_audit:
        :param bool domain_monitor:
        :param str sender_domain:
        :param str folder_id:
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: CreateDevicePreviewRunResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.create_device_preview_run_from_file_with_http_info(file, **kwargs)  # noqa: E501

    def create_device_preview_run_from_file_with_http_info(self, file, **kwargs):  # noqa: E501
        """Create a device preview run from an HTML, EML, or ZIP file  # noqa: E501

        Uploads an HTML or RFC822 EML file, or a ZIP archive containing exactly one HTML or EML file. ZIP uploads are bounded by entry count, expanded size, and compression ratio.  # 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_device_preview_run_from_file_with_http_info(file, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param file file: An .html, .htm, or .eml file, or a .zip archive containing exactly one supported file. (required)
        :param str subject:
        :param str _from:
        :param str to:
        :param str source_alias:
        :param str external_id:
        :param list[str] providers: Legacy web-provider keys to render.
        :param bool all_targets: Render every currently configured target.
        :param list[str] targets: Device preview target keys to render.
        :param bool email_audit:
        :param bool domain_monitor:
        :param str sender_domain:
        :param str folder_id:
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(CreateDevicePreviewRunResult, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'file',
            'subject',
            '_from',
            'to',
            'source_alias',
            'external_id',
            'providers',
            'all_targets',
            'targets',
            'email_audit',
            'domain_monitor',
            'sender_domain',
            'folder_id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

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

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'subject' in local_var_params and local_var_params['subject'] is not None:  # noqa: E501
            query_params.append(('subject', local_var_params['subject']))  # noqa: E501
        if '_from' in local_var_params and local_var_params['_from'] is not None:  # noqa: E501
            query_params.append(('from', local_var_params['_from']))  # noqa: E501
        if 'to' in local_var_params and local_var_params['to'] is not None:  # noqa: E501
            query_params.append(('to', local_var_params['to']))  # noqa: E501
        if 'source_alias' in local_var_params and local_var_params['source_alias'] is not None:  # noqa: E501
            query_params.append(('sourceAlias', local_var_params['source_alias']))  # noqa: E501
        if 'external_id' in local_var_params and local_var_params['external_id'] is not None:  # noqa: E501
            query_params.append(('externalId', local_var_params['external_id']))  # noqa: E501
        if 'providers' in local_var_params and local_var_params['providers'] is not None:  # noqa: E501
            query_params.append(('providers', local_var_params['providers']))  # noqa: E501
            collection_formats['providers'] = 'multi'  # noqa: E501
        if 'all_targets' in local_var_params and local_var_params['all_targets'] is not None:  # noqa: E501
            query_params.append(('allTargets', local_var_params['all_targets']))  # noqa: E501
        if 'targets' in local_var_params and local_var_params['targets'] is not None:  # noqa: E501
            query_params.append(('targets', local_var_params['targets']))  # noqa: E501
            collection_formats['targets'] = 'multi'  # noqa: E501
        if 'email_audit' in local_var_params and local_var_params['email_audit'] is not None:  # noqa: E501
            query_params.append(('emailAudit', local_var_params['email_audit']))  # noqa: E501
        if 'domain_monitor' in local_var_params and local_var_params['domain_monitor'] is not None:  # noqa: E501
            query_params.append(('domainMonitor', local_var_params['domain_monitor']))  # noqa: E501
        if 'sender_domain' in local_var_params and local_var_params['sender_domain'] is not None:  # noqa: E501
            query_params.append(('senderDomain', local_var_params['sender_domain']))  # noqa: E501
        if 'folder_id' in local_var_params and local_var_params['folder_id'] is not None:  # noqa: E501
            query_params.append(('folderId', local_var_params['folder_id']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}
        if 'file' in local_var_params:
            local_var_files['file'] = local_var_params['file']  # noqa: E501

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

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

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

        return self.api_client.call_api(
            '/emails/device-previews/import/file', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CreateDevicePreviewRunResult',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def create_device_preview_run_from_html_import(self, create_device_preview_html_import_options, **kwargs):  # noqa: E501
        """Create a device preview run from HTML  # 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_device_preview_run_from_html_import(create_device_preview_html_import_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param CreateDevicePreviewHtmlImportOptions create_device_preview_html_import_options: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: CreateDevicePreviewRunResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.create_device_preview_run_from_html_import_with_http_info(create_device_preview_html_import_options, **kwargs)  # noqa: E501

    def create_device_preview_run_from_html_import_with_http_info(self, create_device_preview_html_import_options, **kwargs):  # noqa: E501
        """Create a device preview run from HTML  # 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_device_preview_run_from_html_import_with_http_info(create_device_preview_html_import_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param CreateDevicePreviewHtmlImportOptions create_device_preview_html_import_options: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(CreateDevicePreviewRunResult, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'create_device_preview_html_import_options'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

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

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

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

        return self.api_client.call_api(
            '/emails/device-previews/import/html', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CreateDevicePreviewRunResult',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def create_device_preview_run_from_import(self, create_device_preview_import_options, **kwargs):  # noqa: E501
        """Create a device preview run from imported raw MIME  # 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_device_preview_run_from_import(create_device_preview_import_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param CreateDevicePreviewImportOptions create_device_preview_import_options: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: CreateDevicePreviewRunResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.create_device_preview_run_from_import_with_http_info(create_device_preview_import_options, **kwargs)  # noqa: E501

    def create_device_preview_run_from_import_with_http_info(self, create_device_preview_import_options, **kwargs):  # noqa: E501
        """Create a device preview run from imported raw MIME  # 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_device_preview_run_from_import_with_http_info(create_device_preview_import_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param CreateDevicePreviewImportOptions create_device_preview_import_options: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(CreateDevicePreviewRunResult, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'create_device_preview_import_options'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

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

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

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

        return self.api_client.call_api(
            '/emails/device-previews/import', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CreateDevicePreviewRunResult',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def create_device_preview_run_from_multipart_import(self, file, **kwargs):  # noqa: E501
        """Create a device preview run from multipart EML upload  # 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_device_preview_run_from_multipart_import(file, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param file file: (required)
        :param str source_alias:
        :param str external_id:
        :param bool all_targets: Render every currently configured target.
        :param list[str] targets: Device preview target keys to render.
        :param str folder_id:
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: CreateDevicePreviewRunResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.create_device_preview_run_from_multipart_import_with_http_info(file, **kwargs)  # noqa: E501

    def create_device_preview_run_from_multipart_import_with_http_info(self, file, **kwargs):  # noqa: E501
        """Create a device preview run from multipart EML upload  # 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_device_preview_run_from_multipart_import_with_http_info(file, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param file file: (required)
        :param str source_alias:
        :param str external_id:
        :param bool all_targets: Render every currently configured target.
        :param list[str] targets: Device preview target keys to render.
        :param str folder_id:
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(CreateDevicePreviewRunResult, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'file',
            'source_alias',
            'external_id',
            'all_targets',
            'targets',
            'folder_id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

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

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'source_alias' in local_var_params and local_var_params['source_alias'] is not None:  # noqa: E501
            query_params.append(('sourceAlias', local_var_params['source_alias']))  # noqa: E501
        if 'external_id' in local_var_params and local_var_params['external_id'] is not None:  # noqa: E501
            query_params.append(('externalId', local_var_params['external_id']))  # noqa: E501
        if 'all_targets' in local_var_params and local_var_params['all_targets'] is not None:  # noqa: E501
            query_params.append(('allTargets', local_var_params['all_targets']))  # noqa: E501
        if 'targets' in local_var_params and local_var_params['targets'] is not None:  # noqa: E501
            query_params.append(('targets', local_var_params['targets']))  # noqa: E501
            collection_formats['targets'] = 'multi'  # noqa: E501
        if 'folder_id' in local_var_params and local_var_params['folder_id'] is not None:  # noqa: E501
            query_params.append(('folderId', local_var_params['folder_id']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}
        if 'file' in local_var_params:
            local_var_files['file'] = local_var_params['file']  # noqa: E501

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

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

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

        return self.api_client.call_api(
            '/emails/device-previews/import/multipart', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CreateDevicePreviewRunResult',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def create_device_preview_run_from_raw_import(self, **kwargs):  # noqa: E501
        """Create a device preview run from raw MIME bytes  # 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_device_preview_run_from_raw_import(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str source_alias:
        :param str external_id:
        :param bool all_targets: Render every currently configured target.
        :param list[str] targets: Device preview target keys to render.
        :param str folder_id:
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: CreateDevicePreviewRunResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.create_device_preview_run_from_raw_import_with_http_info(**kwargs)  # noqa: E501

    def create_device_preview_run_from_raw_import_with_http_info(self, **kwargs):  # noqa: E501
        """Create a device preview run from raw MIME bytes  # 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_device_preview_run_from_raw_import_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str source_alias:
        :param str external_id:
        :param bool all_targets: Render every currently configured target.
        :param list[str] targets: Device preview target keys to render.
        :param str folder_id:
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(CreateDevicePreviewRunResult, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'source_alias',
            'external_id',
            'all_targets',
            'targets',
            'folder_id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

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

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'source_alias' in local_var_params and local_var_params['source_alias'] is not None:  # noqa: E501
            query_params.append(('sourceAlias', local_var_params['source_alias']))  # noqa: E501
        if 'external_id' in local_var_params and local_var_params['external_id'] is not None:  # noqa: E501
            query_params.append(('externalId', local_var_params['external_id']))  # noqa: E501
        if 'all_targets' in local_var_params and local_var_params['all_targets'] is not None:  # noqa: E501
            query_params.append(('allTargets', local_var_params['all_targets']))  # noqa: E501
        if 'targets' in local_var_params and local_var_params['targets'] is not None:  # noqa: E501
            query_params.append(('targets', local_var_params['targets']))  # noqa: E501
            collection_formats['targets'] = 'multi'  # noqa: E501
        if 'folder_id' in local_var_params and local_var_params['folder_id'] is not None:  # noqa: E501
            query_params.append(('folderId', local_var_params['folder_id']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        return self.api_client.call_api(
            '/emails/device-previews/import/raw', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CreateDevicePreviewRunResult',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def create_device_preview_share_link(self, run_id, **kwargs):  # noqa: E501
        """Create a share link for a device preview run  # 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_device_preview_share_link(run_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str run_id: (required)
        :param CreateDevicePreviewShareLinkOptions create_device_preview_share_link_options:
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: DevicePreviewShareLinkDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.create_device_preview_share_link_with_http_info(run_id, **kwargs)  # noqa: E501

    def create_device_preview_share_link_with_http_info(self, run_id, **kwargs):  # noqa: E501
        """Create a share link for a device preview run  # 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_device_preview_share_link_with_http_info(run_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str run_id: (required)
        :param CreateDevicePreviewShareLinkOptions create_device_preview_share_link_options:
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(DevicePreviewShareLinkDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'run_id',
            'create_device_preview_share_link_options'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

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

        collection_formats = {}

        path_params = {}
        if 'run_id' in local_var_params:
            path_params['runId'] = local_var_params['run_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

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

        return self.api_client.call_api(
            '/emails/device-previews/{runId}/share-links', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DevicePreviewShareLinkDto',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def delete_device_preview_folder(self, folder_id, **kwargs):  # noqa: E501
        """Delete a folder, preserving renders and child folders  # 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_device_preview_folder(folder_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str folder_id: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: DeleteDevicePreviewFolderResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.delete_device_preview_folder_with_http_info(folder_id, **kwargs)  # noqa: E501

    def delete_device_preview_folder_with_http_info(self, folder_id, **kwargs):  # noqa: E501
        """Delete a folder, preserving renders and child folders  # 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_device_preview_folder_with_http_info(folder_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str folder_id: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(DeleteDevicePreviewFolderResult, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'folder_id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

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

        collection_formats = {}

        path_params = {}
        if 'folder_id' in local_var_params:
            path_params['folderId'] = local_var_params['folder_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        return self.api_client.call_api(
            '/emails/device-previews/folders/{folderId}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DeleteDevicePreviewFolderResult',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def delete_device_preview_profile(self, profile_id, **kwargs):  # noqa: E501
        """Delete a device preview 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.delete_device_preview_profile(profile_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str profile_id: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: DeleteDevicePreviewProfileResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.delete_device_preview_profile_with_http_info(profile_id, **kwargs)  # noqa: E501

    def delete_device_preview_profile_with_http_info(self, profile_id, **kwargs):  # noqa: E501
        """Delete a device preview 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.delete_device_preview_profile_with_http_info(profile_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str profile_id: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(DeleteDevicePreviewProfileResult, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'profile_id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

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

        collection_formats = {}

        path_params = {}
        if 'profile_id' in local_var_params:
            path_params['profileId'] = local_var_params['profile_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        return self.api_client.call_api(
            '/emails/device-previews/profiles/{profileId}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DeleteDevicePreviewProfileResult',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def delete_device_preview_run(self, run_id, **kwargs):  # noqa: E501
        """Delete local device preview run data  # 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_device_preview_run(run_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str run_id: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: DeleteDevicePreviewRunResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.delete_device_preview_run_with_http_info(run_id, **kwargs)  # noqa: E501

    def delete_device_preview_run_with_http_info(self, run_id, **kwargs):  # noqa: E501
        """Delete local device preview run data  # 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_device_preview_run_with_http_info(run_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str run_id: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(DeleteDevicePreviewRunResult, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'run_id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

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

        collection_formats = {}

        path_params = {}
        if 'run_id' in local_var_params:
            path_params['runId'] = local_var_params['run_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        return self.api_client.call_api(
            '/emails/device-previews/{runId}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DeleteDevicePreviewRunResult',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def delete_device_preview_share_link(self, share_link_id, **kwargs):  # noqa: E501
        """Revoke a device preview share link  # 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_device_preview_share_link(share_link_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str share_link_id: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: DeleteDevicePreviewShareLinkResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.delete_device_preview_share_link_with_http_info(share_link_id, **kwargs)  # noqa: E501

    def delete_device_preview_share_link_with_http_info(self, share_link_id, **kwargs):  # noqa: E501
        """Revoke a device preview share link  # 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_device_preview_share_link_with_http_info(share_link_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str share_link_id: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(DeleteDevicePreviewShareLinkResult, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'share_link_id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

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

        collection_formats = {}

        path_params = {}
        if 'share_link_id' in local_var_params:
            path_params['shareLinkId'] = local_var_params['share_link_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        return self.api_client.call_api(
            '/emails/device-previews/share-links/{shareLinkId}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DeleteDevicePreviewShareLinkResult',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def download_device_preview_email_submission_source_email(self, submission_id, **kwargs):  # noqa: E501
        """Download the original RFC822 email for a device preview submission  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.download_device_preview_email_submission_source_email(submission_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str submission_id: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: file
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.download_device_preview_email_submission_source_email_with_http_info(submission_id, **kwargs)  # noqa: E501

    def download_device_preview_email_submission_source_email_with_http_info(self, submission_id, **kwargs):  # noqa: E501
        """Download the original RFC822 email for a device preview submission  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.download_device_preview_email_submission_source_email_with_http_info(submission_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str submission_id: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(file, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'submission_id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

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

        collection_formats = {}

        path_params = {}
        if 'submission_id' in local_var_params:
            path_params['submissionId'] = local_var_params['submission_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        return self.api_client.call_api(
            '/emails/device-previews/email-submissions/{submissionId}/source-email/raw', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='file',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def download_device_preview_run_source_email(self, run_id, **kwargs):  # noqa: E501
        """Download the original RFC822 email for a device preview run  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.download_device_preview_run_source_email(run_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str run_id: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: file
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.download_device_preview_run_source_email_with_http_info(run_id, **kwargs)  # noqa: E501

    def download_device_preview_run_source_email_with_http_info(self, run_id, **kwargs):  # noqa: E501
        """Download the original RFC822 email for a device preview run  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.download_device_preview_run_source_email_with_http_info(run_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str run_id: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(file, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'run_id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

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

        collection_formats = {}

        path_params = {}
        if 'run_id' in local_var_params:
            path_params['runId'] = local_var_params['run_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        return self.api_client.call_api(
            '/emails/device-previews/{runId}/source-email/raw', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='file',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def ensure_device_preview_run(self, email_id, **kwargs):  # noqa: E501
        """Return active run for email or create one when none exists  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.ensure_device_preview_run(email_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: (required)
        :param CreateDevicePreviewOptions create_device_preview_options:
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: CreateDevicePreviewRunResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.ensure_device_preview_run_with_http_info(email_id, **kwargs)  # noqa: E501

    def ensure_device_preview_run_with_http_info(self, email_id, **kwargs):  # noqa: E501
        """Return active run for email or create one when none exists  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.ensure_device_preview_run_with_http_info(email_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: (required)
        :param CreateDevicePreviewOptions create_device_preview_options:
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(CreateDevicePreviewRunResult, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'email_id',
            'create_device_preview_options'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

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

        collection_formats = {}

        path_params = {}
        if 'email_id' in local_var_params:
            path_params['emailId'] = local_var_params['email_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

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

        return self.api_client.call_api(
            '/emails/{emailId}/device-previews/latest', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='CreateDevicePreviewRunResult',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_device_preview_email_domain_or_create(self, **kwargs):  # noqa: E501
        """Return account device preview email domain setup or create one  # 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_device_preview_email_domain_or_create(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: DevicePreviewAccountSettingsDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_device_preview_email_domain_or_create_with_http_info(**kwargs)  # noqa: E501

    def get_device_preview_email_domain_or_create_with_http_info(self, **kwargs):  # noqa: E501
        """Return account device preview email domain setup or create one  # 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_device_preview_email_domain_or_create_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(DevicePreviewAccountSettingsDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

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

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

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        return self.api_client.call_api(
            '/emails/device-previews/email-domain', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DevicePreviewAccountSettingsDto',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_device_preview_email_runs(self, since, **kwargs):  # noqa: E501
        """List device preview runs created from account email domains  # 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_device_preview_email_runs(since, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param datetime since: (required)
        :param str email_domain_id:
        :param str profile_id:
        :param str local_part:
        :param int limit:
        :param bool hydrate_thumbnail: Hydrate each returned run with a nullable primary screenshot thumbnail URL.
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: list[DevicePreviewRunDto]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_device_preview_email_runs_with_http_info(since, **kwargs)  # noqa: E501

    def get_device_preview_email_runs_with_http_info(self, since, **kwargs):  # noqa: E501
        """List device preview runs created from account email domains  # 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_device_preview_email_runs_with_http_info(since, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param datetime since: (required)
        :param str email_domain_id:
        :param str profile_id:
        :param str local_part:
        :param int limit:
        :param bool hydrate_thumbnail: Hydrate each returned run with a nullable primary screenshot thumbnail URL.
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(list[DevicePreviewRunDto], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'since',
            'email_domain_id',
            'profile_id',
            'local_part',
            'limit',
            'hydrate_thumbnail'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

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

        if self.api_client.client_side_validation and 'limit' in local_var_params and local_var_params['limit'] > 100:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `limit` when calling `get_device_preview_email_runs`, must be a value less than or equal to `100`")  # noqa: E501
        collection_formats = {}

        path_params = {}

        query_params = []
        if 'since' in local_var_params and local_var_params['since'] is not None:  # noqa: E501
            query_params.append(('since', local_var_params['since']))  # noqa: E501
        if 'email_domain_id' in local_var_params and local_var_params['email_domain_id'] is not None:  # noqa: E501
            query_params.append(('emailDomainId', local_var_params['email_domain_id']))  # noqa: E501
        if 'profile_id' in local_var_params and local_var_params['profile_id'] is not None:  # noqa: E501
            query_params.append(('profileId', local_var_params['profile_id']))  # noqa: E501
        if 'local_part' in local_var_params and local_var_params['local_part'] is not None:  # noqa: E501
            query_params.append(('localPart', local_var_params['local_part']))  # noqa: E501
        if 'limit' in local_var_params and local_var_params['limit'] is not None:  # noqa: E501
            query_params.append(('limit', local_var_params['limit']))  # noqa: E501
        if 'hydrate_thumbnail' in local_var_params and local_var_params['hydrate_thumbnail'] is not None:  # noqa: E501
            query_params.append(('hydrateThumbnail', local_var_params['hydrate_thumbnail']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        return self.api_client.call_api(
            '/emails/device-previews/email-runs', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[DevicePreviewRunDto]',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_device_preview_email_submission_source_email(self, submission_id, **kwargs):  # noqa: E501
        """Get the original email content for a device preview submission  # 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_device_preview_email_submission_source_email(submission_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str submission_id: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: DevicePreviewSourceEmailDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_device_preview_email_submission_source_email_with_http_info(submission_id, **kwargs)  # noqa: E501

    def get_device_preview_email_submission_source_email_with_http_info(self, submission_id, **kwargs):  # noqa: E501
        """Get the original email content for a device preview submission  # 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_device_preview_email_submission_source_email_with_http_info(submission_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str submission_id: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(DevicePreviewSourceEmailDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'submission_id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

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

        collection_formats = {}

        path_params = {}
        if 'submission_id' in local_var_params:
            path_params['submissionId'] = local_var_params['submission_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        return self.api_client.call_api(
            '/emails/device-previews/email-submissions/{submissionId}/source-email', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DevicePreviewSourceEmailDto',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_device_preview_email_submissions(self, since, **kwargs):  # noqa: E501
        """List received device preview email submissions  # 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_device_preview_email_submissions(since, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param datetime since: (required)
        :param str email_domain_id:
        :param str profile_id:
        :param str local_part:
        :param int limit:
        :param str recipient_email_address:
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: list[DevicePreviewEmailSubmissionDto]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_device_preview_email_submissions_with_http_info(since, **kwargs)  # noqa: E501

    def get_device_preview_email_submissions_with_http_info(self, since, **kwargs):  # noqa: E501
        """List received device preview email submissions  # 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_device_preview_email_submissions_with_http_info(since, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param datetime since: (required)
        :param str email_domain_id:
        :param str profile_id:
        :param str local_part:
        :param int limit:
        :param str recipient_email_address:
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(list[DevicePreviewEmailSubmissionDto], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'since',
            'email_domain_id',
            'profile_id',
            'local_part',
            'limit',
            'recipient_email_address'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

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

        if self.api_client.client_side_validation and 'limit' in local_var_params and local_var_params['limit'] > 100:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `limit` when calling `get_device_preview_email_submissions`, must be a value less than or equal to `100`")  # noqa: E501
        collection_formats = {}

        path_params = {}

        query_params = []
        if 'since' in local_var_params and local_var_params['since'] is not None:  # noqa: E501
            query_params.append(('since', local_var_params['since']))  # noqa: E501
        if 'email_domain_id' in local_var_params and local_var_params['email_domain_id'] is not None:  # noqa: E501
            query_params.append(('emailDomainId', local_var_params['email_domain_id']))  # noqa: E501
        if 'profile_id' in local_var_params and local_var_params['profile_id'] is not None:  # noqa: E501
            query_params.append(('profileId', local_var_params['profile_id']))  # noqa: E501
        if 'local_part' in local_var_params and local_var_params['local_part'] is not None:  # noqa: E501
            query_params.append(('localPart', local_var_params['local_part']))  # noqa: E501
        if 'limit' in local_var_params and local_var_params['limit'] is not None:  # noqa: E501
            query_params.append(('limit', local_var_params['limit']))  # noqa: E501
        if 'recipient_email_address' in local_var_params and local_var_params['recipient_email_address'] is not None:  # noqa: E501
            query_params.append(('recipientEmailAddress', local_var_params['recipient_email_address']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        return self.api_client.call_api(
            '/emails/device-previews/email-submissions', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[DevicePreviewEmailSubmissionDto]',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_device_preview_feedback(self, feedback_id, **kwargs):  # noqa: E501
        """Get a single device preview feedback item  # 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_device_preview_feedback(feedback_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str feedback_id: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: DevicePreviewFeedbackDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_device_preview_feedback_with_http_info(feedback_id, **kwargs)  # noqa: E501

    def get_device_preview_feedback_with_http_info(self, feedback_id, **kwargs):  # noqa: E501
        """Get a single device preview feedback item  # 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_device_preview_feedback_with_http_info(feedback_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str feedback_id: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(DevicePreviewFeedbackDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'feedback_id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

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

        collection_formats = {}

        path_params = {}
        if 'feedback_id' in local_var_params:
            path_params['feedbackId'] = local_var_params['feedback_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        return self.api_client.call_api(
            '/emails/device-previews/feedback/{feedbackId}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DevicePreviewFeedbackDto',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_device_preview_feedback_items(self, **kwargs):  # noqa: E501
        """List device preview feedback  # 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_device_preview_feedback_items(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int page:
        :param int size:
        :param str source:
        :param str run_id:
        :param str status:
        :param str provider:
        :param str category:
        :param str search:
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: DevicePreviewFeedbackListDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_device_preview_feedback_items_with_http_info(**kwargs)  # noqa: E501

    def get_device_preview_feedback_items_with_http_info(self, **kwargs):  # noqa: E501
        """List device preview feedback  # 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_device_preview_feedback_items_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int page:
        :param int size:
        :param str source:
        :param str run_id:
        :param str status:
        :param str provider:
        :param str category:
        :param str search:
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(DevicePreviewFeedbackListDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'page',
            'size',
            'source',
            'run_id',
            'status',
            'provider',
            'category',
            'search'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

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

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'page' in local_var_params and local_var_params['page'] is not None:  # noqa: E501
            query_params.append(('page', local_var_params['page']))  # noqa: E501
        if 'size' in local_var_params and local_var_params['size'] is not None:  # noqa: E501
            query_params.append(('size', local_var_params['size']))  # noqa: E501
        if 'source' in local_var_params and local_var_params['source'] is not None:  # noqa: E501
            query_params.append(('source', local_var_params['source']))  # noqa: E501
        if 'run_id' in local_var_params and local_var_params['run_id'] is not None:  # noqa: E501
            query_params.append(('runId', local_var_params['run_id']))  # noqa: E501
        if 'status' in local_var_params and local_var_params['status'] is not None:  # noqa: E501
            query_params.append(('status', local_var_params['status']))  # noqa: E501
        if 'provider' in local_var_params and local_var_params['provider'] is not None:  # noqa: E501
            query_params.append(('provider', local_var_params['provider']))  # noqa: E501
        if 'category' in local_var_params and local_var_params['category'] is not None:  # noqa: E501
            query_params.append(('category', local_var_params['category']))  # noqa: E501
        if 'search' in local_var_params and local_var_params['search'] is not None:  # noqa: E501
            query_params.append(('search', local_var_params['search']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

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

    def get_device_preview_folder(self, folder_id, **kwargs):  # noqa: E501
        """Get a device preview folder  # 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_device_preview_folder(folder_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str folder_id: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: DevicePreviewFolderDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_device_preview_folder_with_http_info(folder_id, **kwargs)  # noqa: E501

    def get_device_preview_folder_with_http_info(self, folder_id, **kwargs):  # noqa: E501
        """Get a device preview folder  # 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_device_preview_folder_with_http_info(folder_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str folder_id: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(DevicePreviewFolderDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'folder_id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

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

        collection_formats = {}

        path_params = {}
        if 'folder_id' in local_var_params:
            path_params['folderId'] = local_var_params['folder_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        return self.api_client.call_api(
            '/emails/device-previews/folders/{folderId}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DevicePreviewFolderDto',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_device_preview_folders(self, **kwargs):  # noqa: E501
        """List device preview folders  # 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_device_preview_folders(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: list[DevicePreviewFolderDto]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_device_preview_folders_with_http_info(**kwargs)  # noqa: E501

    def get_device_preview_folders_with_http_info(self, **kwargs):  # noqa: E501
        """List device preview folders  # 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_device_preview_folders_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(list[DevicePreviewFolderDto], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

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

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

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        return self.api_client.call_api(
            '/emails/device-previews/folders', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[DevicePreviewFolderDto]',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_device_preview_import_address(self, session_id, **kwargs):  # noqa: E501
        """Get temporary device preview import address status  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_device_preview_import_address(session_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str session_id: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: DevicePreviewIngestAddressDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_device_preview_import_address_with_http_info(session_id, **kwargs)  # noqa: E501

    def get_device_preview_import_address_with_http_info(self, session_id, **kwargs):  # noqa: E501
        """Get temporary device preview import address status  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_device_preview_import_address_with_http_info(session_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str session_id: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(DevicePreviewIngestAddressDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'session_id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

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

        collection_formats = {}

        path_params = {}
        if 'session_id' in local_var_params:
            path_params['sessionId'] = local_var_params['session_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        return self.api_client.call_api(
            '/emails/device-previews/import-addresses/{sessionId}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DevicePreviewIngestAddressDto',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_device_preview_native_target_availability(self, **kwargs):  # noqa: E501
        """Get native device preview target availability  # noqa: E501

        Returns live native device preview target availability for authenticated API clients, including worker health, queue, timeout, and status fields. Use `/device-preview-targets` when you need the stable catalog without transient availability data.  # 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_device_preview_native_target_availability(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: DevicePreviewNativeTargetAvailabilityListDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_device_preview_native_target_availability_with_http_info(**kwargs)  # noqa: E501

    def get_device_preview_native_target_availability_with_http_info(self, **kwargs):  # noqa: E501
        """Get native device preview target availability  # noqa: E501

        Returns live native device preview target availability for authenticated API clients, including worker health, queue, timeout, and status fields. Use `/device-preview-targets` when you need the stable catalog without transient availability data.  # 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_device_preview_native_target_availability_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(DevicePreviewNativeTargetAvailabilityListDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

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

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

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        return self.api_client.call_api(
            '/emails/device-previews/native-targets/availability', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DevicePreviewNativeTargetAvailabilityListDto',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_device_preview_profile(self, profile_id, **kwargs):  # noqa: E501
        """Get a device preview 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.get_device_preview_profile(profile_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str profile_id: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: DevicePreviewProfileDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_device_preview_profile_with_http_info(profile_id, **kwargs)  # noqa: E501

    def get_device_preview_profile_with_http_info(self, profile_id, **kwargs):  # noqa: E501
        """Get a device preview 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.get_device_preview_profile_with_http_info(profile_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str profile_id: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(DevicePreviewProfileDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'profile_id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

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

        collection_formats = {}

        path_params = {}
        if 'profile_id' in local_var_params:
            path_params['profileId'] = local_var_params['profile_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        return self.api_client.call_api(
            '/emails/device-previews/profiles/{profileId}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DevicePreviewProfileDto',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_device_preview_profiles(self, **kwargs):  # noqa: E501
        """List device preview profiles  # 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_device_preview_profiles(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: list[DevicePreviewProfileDto]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_device_preview_profiles_with_http_info(**kwargs)  # noqa: E501

    def get_device_preview_profiles_with_http_info(self, **kwargs):  # noqa: E501
        """List device preview profiles  # 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_device_preview_profiles_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(list[DevicePreviewProfileDto], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

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

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

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        return self.api_client.call_api(
            '/emails/device-previews/profiles', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[DevicePreviewProfileDto]',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_device_preview_run(self, run_id, **kwargs):  # noqa: E501
        """Get device preview run status  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_device_preview_run(run_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str run_id: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: DevicePreviewRunDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_device_preview_run_with_http_info(run_id, **kwargs)  # noqa: E501

    def get_device_preview_run_with_http_info(self, run_id, **kwargs):  # noqa: E501
        """Get device preview run status  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_device_preview_run_with_http_info(run_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str run_id: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(DevicePreviewRunDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'run_id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

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

        collection_formats = {}

        path_params = {}
        if 'run_id' in local_var_params:
            path_params['runId'] = local_var_params['run_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        return self.api_client.call_api(
            '/emails/device-previews/{runId}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DevicePreviewRunDto',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_device_preview_run_provider_progress(self, run_id, provider, **kwargs):  # noqa: E501
        """Get provider-level progress for a device preview run  # 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_device_preview_run_provider_progress(run_id, provider, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str run_id: (required)
        :param str provider: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: DevicePreviewProviderProgressDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_device_preview_run_provider_progress_with_http_info(run_id, provider, **kwargs)  # noqa: E501

    def get_device_preview_run_provider_progress_with_http_info(self, run_id, provider, **kwargs):  # noqa: E501
        """Get provider-level progress for a device preview run  # 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_device_preview_run_provider_progress_with_http_info(run_id, provider, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str run_id: (required)
        :param str provider: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(DevicePreviewProviderProgressDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'run_id',
            'provider'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

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

        collection_formats = {}

        path_params = {}
        if 'run_id' in local_var_params:
            path_params['runId'] = local_var_params['run_id']  # noqa: E501
        if 'provider' in local_var_params:
            path_params['provider'] = local_var_params['provider']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        return self.api_client.call_api(
            '/emails/device-previews/{runId}/providers/{provider}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DevicePreviewProviderProgressDto',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_device_preview_run_results(self, run_id, **kwargs):  # noqa: E501
        """Get device preview run results  # 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_device_preview_run_results(run_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str run_id: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: DevicePreviewRunResultsDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_device_preview_run_results_with_http_info(run_id, **kwargs)  # noqa: E501

    def get_device_preview_run_results_with_http_info(self, run_id, **kwargs):  # noqa: E501
        """Get device preview run results  # 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_device_preview_run_results_with_http_info(run_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str run_id: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(DevicePreviewRunResultsDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'run_id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

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

        collection_formats = {}

        path_params = {}
        if 'run_id' in local_var_params:
            path_params['runId'] = local_var_params['run_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        return self.api_client.call_api(
            '/emails/device-previews/{runId}/results', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DevicePreviewRunResultsDto',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_device_preview_run_screenshot(self, run_id, screenshot_id, **kwargs):  # noqa: E501
        """Get a device preview screenshot image  # 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_device_preview_run_screenshot(run_id, screenshot_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str run_id: (required)
        :param str screenshot_id: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: str
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_device_preview_run_screenshot_with_http_info(run_id, screenshot_id, **kwargs)  # noqa: E501

    def get_device_preview_run_screenshot_with_http_info(self, run_id, screenshot_id, **kwargs):  # noqa: E501
        """Get a device preview screenshot image  # 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_device_preview_run_screenshot_with_http_info(run_id, screenshot_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str run_id: (required)
        :param str screenshot_id: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(str, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'run_id',
            'screenshot_id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

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

        collection_formats = {}

        path_params = {}
        if 'run_id' in local_var_params:
            path_params['runId'] = local_var_params['run_id']  # noqa: E501
        if 'screenshot_id' in local_var_params:
            path_params['screenshotId'] = local_var_params['screenshot_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        return self.api_client.call_api(
            '/emails/device-previews/{runId}/screenshots/{screenshotId}/image', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='str',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_device_preview_run_source_email(self, run_id, **kwargs):  # noqa: E501
        """Get the original email content for a device preview run  # 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_device_preview_run_source_email(run_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str run_id: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: DevicePreviewSourceEmailDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_device_preview_run_source_email_with_http_info(run_id, **kwargs)  # noqa: E501

    def get_device_preview_run_source_email_with_http_info(self, run_id, **kwargs):  # noqa: E501
        """Get the original email content for a device preview run  # 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_device_preview_run_source_email_with_http_info(run_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str run_id: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(DevicePreviewSourceEmailDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'run_id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

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

        collection_formats = {}

        path_params = {}
        if 'run_id' in local_var_params:
            path_params['runId'] = local_var_params['run_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        return self.api_client.call_api(
            '/emails/device-previews/{runId}/source-email', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DevicePreviewSourceEmailDto',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_device_preview_runs(self, email_id, **kwargs):  # noqa: E501
        """List previous device preview runs for an email  # 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_device_preview_runs(email_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: (required)
        :param int limit:
        :param bool hydrate_thumbnail: Hydrate each returned run with a nullable primary screenshot thumbnail URL.
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: list[DevicePreviewRunDto]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_device_preview_runs_with_http_info(email_id, **kwargs)  # noqa: E501

    def get_device_preview_runs_with_http_info(self, email_id, **kwargs):  # noqa: E501
        """List previous device preview runs for an email  # 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_device_preview_runs_with_http_info(email_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: (required)
        :param int limit:
        :param bool hydrate_thumbnail: Hydrate each returned run with a nullable primary screenshot thumbnail URL.
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(list[DevicePreviewRunDto], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'email_id',
            'limit',
            'hydrate_thumbnail'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

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

        collection_formats = {}

        path_params = {}
        if 'email_id' in local_var_params:
            path_params['emailId'] = local_var_params['email_id']  # noqa: E501

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

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        return self.api_client.call_api(
            '/emails/{emailId}/device-previews', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[DevicePreviewRunDto]',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_device_preview_runs_for_account(self, **kwargs):  # noqa: E501
        """List previous device preview runs for account  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_device_preview_runs_for_account(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int limit:
        :param bool hydrate_thumbnail: Hydrate each returned run with a nullable primary screenshot thumbnail URL.
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: list[DevicePreviewRunDto]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_device_preview_runs_for_account_with_http_info(**kwargs)  # noqa: E501

    def get_device_preview_runs_for_account_with_http_info(self, **kwargs):  # noqa: E501
        """List previous device preview runs for account  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_device_preview_runs_for_account_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int limit:
        :param bool hydrate_thumbnail: Hydrate each returned run with a nullable primary screenshot thumbnail URL.
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(list[DevicePreviewRunDto], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'limit',
            'hydrate_thumbnail'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

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

        collection_formats = {}

        path_params = {}

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

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        return self.api_client.call_api(
            '/emails/device-previews', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[DevicePreviewRunDto]',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_device_preview_runs_for_account_offset_paginated(self, **kwargs):  # noqa: E501
        """List previous device preview runs for account in paginated form  # 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_device_preview_runs_for_account_offset_paginated(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int page: Optional page index in list pagination
        :param int size: Optional page size for paginated result list.
        :param str sort: Optional createdAt sort direction ASC or DESC
        :param bool hydrate_thumbnail: Hydrate each returned run with a nullable primary screenshot thumbnail URL.
        :param str folder_id:
        :param bool unfiled_only:
        :param str email_id:
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: PageDevicePreviewRunProjection
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_device_preview_runs_for_account_offset_paginated_with_http_info(**kwargs)  # noqa: E501

    def get_device_preview_runs_for_account_offset_paginated_with_http_info(self, **kwargs):  # noqa: E501
        """List previous device preview runs for account in paginated form  # 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_device_preview_runs_for_account_offset_paginated_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int page: Optional page index in list pagination
        :param int size: Optional page size for paginated result list.
        :param str sort: Optional createdAt sort direction ASC or DESC
        :param bool hydrate_thumbnail: Hydrate each returned run with a nullable primary screenshot thumbnail URL.
        :param str folder_id:
        :param bool unfiled_only:
        :param str email_id:
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(PageDevicePreviewRunProjection, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'page',
            'size',
            'sort',
            'hydrate_thumbnail',
            'folder_id',
            'unfiled_only',
            'email_id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

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

        if self.api_client.client_side_validation and 'size' in local_var_params and local_var_params['size'] > 20:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `size` when calling `get_device_preview_runs_for_account_offset_paginated`, must be a value less than or equal to `20`")  # noqa: E501
        collection_formats = {}

        path_params = {}

        query_params = []
        if 'page' in local_var_params and local_var_params['page'] is not None:  # noqa: E501
            query_params.append(('page', local_var_params['page']))  # noqa: E501
        if 'size' in local_var_params and local_var_params['size'] is not None:  # noqa: E501
            query_params.append(('size', local_var_params['size']))  # noqa: E501
        if 'sort' in local_var_params and local_var_params['sort'] is not None:  # noqa: E501
            query_params.append(('sort', local_var_params['sort']))  # noqa: E501
        if 'hydrate_thumbnail' in local_var_params and local_var_params['hydrate_thumbnail'] is not None:  # noqa: E501
            query_params.append(('hydrateThumbnail', local_var_params['hydrate_thumbnail']))  # noqa: E501
        if 'folder_id' in local_var_params and local_var_params['folder_id'] is not None:  # noqa: E501
            query_params.append(('folderId', local_var_params['folder_id']))  # noqa: E501
        if 'unfiled_only' in local_var_params and local_var_params['unfiled_only'] is not None:  # noqa: E501
            query_params.append(('unfiledOnly', local_var_params['unfiled_only']))  # noqa: E501
        if 'email_id' in local_var_params and local_var_params['email_id'] is not None:  # noqa: E501
            query_params.append(('emailId', local_var_params['email_id']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        return self.api_client.call_api(
            '/emails/device-previews/offset-paginated', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PageDevicePreviewRunProjection',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_device_preview_runs_offset_paginated(self, email_id, **kwargs):  # noqa: E501
        """List previous device preview runs for an email in paginated form  # 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_device_preview_runs_offset_paginated(email_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: (required)
        :param int page: Optional page index in list pagination
        :param int size: Optional page size for paginated result list.
        :param str sort: Optional createdAt sort direction ASC or DESC
        :param bool hydrate_thumbnail: Hydrate each returned run with a nullable primary screenshot thumbnail URL.
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: PageDevicePreviewRunProjection
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_device_preview_runs_offset_paginated_with_http_info(email_id, **kwargs)  # noqa: E501

    def get_device_preview_runs_offset_paginated_with_http_info(self, email_id, **kwargs):  # noqa: E501
        """List previous device preview runs for an email in paginated form  # 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_device_preview_runs_offset_paginated_with_http_info(email_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str email_id: (required)
        :param int page: Optional page index in list pagination
        :param int size: Optional page size for paginated result list.
        :param str sort: Optional createdAt sort direction ASC or DESC
        :param bool hydrate_thumbnail: Hydrate each returned run with a nullable primary screenshot thumbnail URL.
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(PageDevicePreviewRunProjection, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'email_id',
            'page',
            'size',
            'sort',
            'hydrate_thumbnail'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

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

        if self.api_client.client_side_validation and 'size' in local_var_params and local_var_params['size'] > 100:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `size` when calling `get_device_preview_runs_offset_paginated`, must be a value less than or equal to `100`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'email_id' in local_var_params:
            path_params['emailId'] = local_var_params['email_id']  # noqa: E501

        query_params = []
        if 'page' in local_var_params and local_var_params['page'] is not None:  # noqa: E501
            query_params.append(('page', local_var_params['page']))  # noqa: E501
        if 'size' in local_var_params and local_var_params['size'] is not None:  # noqa: E501
            query_params.append(('size', local_var_params['size']))  # noqa: E501
        if 'sort' in local_var_params and local_var_params['sort'] is not None:  # noqa: E501
            query_params.append(('sort', local_var_params['sort']))  # noqa: E501
        if 'hydrate_thumbnail' in local_var_params and local_var_params['hydrate_thumbnail'] is not None:  # noqa: E501
            query_params.append(('hydrateThumbnail', local_var_params['hydrate_thumbnail']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        return self.api_client.call_api(
            '/emails/{emailId}/device-previews/offset-paginated', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='PageDevicePreviewRunProjection',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_device_preview_share_links(self, run_id, **kwargs):  # noqa: E501
        """List share links for a device preview run  # 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_device_preview_share_links(run_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str run_id: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: list[DevicePreviewShareLinkDto]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_device_preview_share_links_with_http_info(run_id, **kwargs)  # noqa: E501

    def get_device_preview_share_links_with_http_info(self, run_id, **kwargs):  # noqa: E501
        """List share links for a device preview run  # 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_device_preview_share_links_with_http_info(run_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str run_id: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(list[DevicePreviewShareLinkDto], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'run_id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

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

        collection_formats = {}

        path_params = {}
        if 'run_id' in local_var_params:
            path_params['runId'] = local_var_params['run_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        return self.api_client.call_api(
            '/emails/device-previews/{runId}/share-links', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[DevicePreviewShareLinkDto]',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_device_preview_shared_result(self, share_token, **kwargs):  # noqa: E501
        """Get a public shared device preview result  # 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_device_preview_shared_result(share_token, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str share_token: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: DevicePreviewSharedResultDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_device_preview_shared_result_with_http_info(share_token, **kwargs)  # noqa: E501

    def get_device_preview_shared_result_with_http_info(self, share_token, **kwargs):  # noqa: E501
        """Get a public shared device preview result  # 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_device_preview_shared_result_with_http_info(share_token, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str share_token: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(DevicePreviewSharedResultDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'share_token'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

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

        collection_formats = {}

        path_params = {}
        if 'share_token' in local_var_params:
            path_params['shareToken'] = local_var_params['share_token']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        return self.api_client.call_api(
            '/emails/device-previews/share/{shareToken}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DevicePreviewSharedResultDto',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_device_preview_shared_result_screenshot(self, share_token, screenshot_id, **kwargs):  # noqa: E501
        """Get a public shared device preview screenshot image  # 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_device_preview_shared_result_screenshot(share_token, screenshot_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str share_token: (required)
        :param str screenshot_id: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: str
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_device_preview_shared_result_screenshot_with_http_info(share_token, screenshot_id, **kwargs)  # noqa: E501

    def get_device_preview_shared_result_screenshot_with_http_info(self, share_token, screenshot_id, **kwargs):  # noqa: E501
        """Get a public shared device preview screenshot image  # 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_device_preview_shared_result_screenshot_with_http_info(share_token, screenshot_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str share_token: (required)
        :param str screenshot_id: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(str, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'share_token',
            'screenshot_id'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

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

        collection_formats = {}

        path_params = {}
        if 'share_token' in local_var_params:
            path_params['shareToken'] = local_var_params['share_token']  # noqa: E501
        if 'screenshot_id' in local_var_params:
            path_params['screenshotId'] = local_var_params['screenshot_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        return self.api_client.call_api(
            '/emails/device-previews/share/{shareToken}/screenshots/{screenshotId}/image', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='str',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_device_preview_targets(self, **kwargs):  # noqa: E501
        """List device preview targets  # noqa: E501

        Returns visible native device preview target metadata without worker availability, queue, or health fields.  # 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_device_preview_targets(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: DevicePreviewNativeTargetListDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_device_preview_targets_with_http_info(**kwargs)  # noqa: E501

    def get_device_preview_targets_with_http_info(self, **kwargs):  # noqa: E501
        """List device preview targets  # noqa: E501

        Returns visible native device preview target metadata without worker availability, queue, or health fields.  # 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_device_preview_targets_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(DevicePreviewNativeTargetListDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

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

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

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

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

    def move_device_preview_runs(self, move_device_preview_runs_options, **kwargs):  # noqa: E501
        """Move device preview runs to a folder or Unfiled  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.move_device_preview_runs(move_device_preview_runs_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param MoveDevicePreviewRunsOptions move_device_preview_runs_options: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: MoveDevicePreviewRunsResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.move_device_preview_runs_with_http_info(move_device_preview_runs_options, **kwargs)  # noqa: E501

    def move_device_preview_runs_with_http_info(self, move_device_preview_runs_options, **kwargs):  # noqa: E501
        """Move device preview runs to a folder or Unfiled  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.move_device_preview_runs_with_http_info(move_device_preview_runs_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param MoveDevicePreviewRunsOptions move_device_preview_runs_options: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(MoveDevicePreviewRunsResult, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'move_device_preview_runs_options'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

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

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

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

        return self.api_client.call_api(
            '/emails/device-previews/folders/runs', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='MoveDevicePreviewRunsResult',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def rerun_device_preview_targets(self, run_id, rerun_device_preview_targets_options, **kwargs):  # noqa: E501
        """Rerun selected device preview targets in the same run  # noqa: E501

        Set failedOnly=false to rerun a successful target. Successful targets consume their configured credit cost again.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.rerun_device_preview_targets(run_id, rerun_device_preview_targets_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str run_id: (required)
        :param RerunDevicePreviewTargetsOptions rerun_device_preview_targets_options: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: RerunDevicePreviewTargetsResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.rerun_device_preview_targets_with_http_info(run_id, rerun_device_preview_targets_options, **kwargs)  # noqa: E501

    def rerun_device_preview_targets_with_http_info(self, run_id, rerun_device_preview_targets_options, **kwargs):  # noqa: E501
        """Rerun selected device preview targets in the same run  # noqa: E501

        Set failedOnly=false to rerun a successful target. Successful targets consume their configured credit cost again.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.rerun_device_preview_targets_with_http_info(run_id, rerun_device_preview_targets_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str run_id: (required)
        :param RerunDevicePreviewTargetsOptions rerun_device_preview_targets_options: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(RerunDevicePreviewTargetsResult, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'run_id',
            'rerun_device_preview_targets_options'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

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

        collection_formats = {}

        path_params = {}
        if 'run_id' in local_var_params:
            path_params['runId'] = local_var_params['run_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

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

        return self.api_client.call_api(
            '/emails/device-previews/{runId}/targets/rerun', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='RerunDevicePreviewTargetsResult',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def update_device_preview_email_domain_subdomain(self, update_device_preview_ingest_domain_options, **kwargs):  # noqa: E501
        """Update account device preview email subdomain  # 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_device_preview_email_domain_subdomain(update_device_preview_ingest_domain_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param UpdateDevicePreviewIngestDomainOptions update_device_preview_ingest_domain_options: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: DevicePreviewAccountSettingsDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.update_device_preview_email_domain_subdomain_with_http_info(update_device_preview_ingest_domain_options, **kwargs)  # noqa: E501

    def update_device_preview_email_domain_subdomain_with_http_info(self, update_device_preview_ingest_domain_options, **kwargs):  # noqa: E501
        """Update account device preview email subdomain  # 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_device_preview_email_domain_subdomain_with_http_info(update_device_preview_ingest_domain_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param UpdateDevicePreviewIngestDomainOptions update_device_preview_ingest_domain_options: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(DevicePreviewAccountSettingsDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'update_device_preview_ingest_domain_options'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

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

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

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

        return self.api_client.call_api(
            '/emails/device-previews/email-domain/subdomain', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DevicePreviewAccountSettingsDto',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def update_device_preview_feedback(self, feedback_id, update_device_preview_feedback_options, **kwargs):  # noqa: E501
        """Update device preview feedback  # 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_device_preview_feedback(feedback_id, update_device_preview_feedback_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str feedback_id: (required)
        :param UpdateDevicePreviewFeedbackOptions update_device_preview_feedback_options: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: DevicePreviewFeedbackDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.update_device_preview_feedback_with_http_info(feedback_id, update_device_preview_feedback_options, **kwargs)  # noqa: E501

    def update_device_preview_feedback_with_http_info(self, feedback_id, update_device_preview_feedback_options, **kwargs):  # noqa: E501
        """Update device preview feedback  # 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_device_preview_feedback_with_http_info(feedback_id, update_device_preview_feedback_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str feedback_id: (required)
        :param UpdateDevicePreviewFeedbackOptions update_device_preview_feedback_options: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(DevicePreviewFeedbackDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'feedback_id',
            'update_device_preview_feedback_options'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

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

        collection_formats = {}

        path_params = {}
        if 'feedback_id' in local_var_params:
            path_params['feedbackId'] = local_var_params['feedback_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

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

        return self.api_client.call_api(
            '/emails/device-previews/feedback/{feedbackId}', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DevicePreviewFeedbackDto',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def update_device_preview_folder(self, folder_id, update_device_preview_folder_options, **kwargs):  # noqa: E501
        """Rename or move a device preview folder  # 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_device_preview_folder(folder_id, update_device_preview_folder_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str folder_id: (required)
        :param UpdateDevicePreviewFolderOptions update_device_preview_folder_options: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: DevicePreviewFolderDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.update_device_preview_folder_with_http_info(folder_id, update_device_preview_folder_options, **kwargs)  # noqa: E501

    def update_device_preview_folder_with_http_info(self, folder_id, update_device_preview_folder_options, **kwargs):  # noqa: E501
        """Rename or move a device preview folder  # 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_device_preview_folder_with_http_info(folder_id, update_device_preview_folder_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str folder_id: (required)
        :param UpdateDevicePreviewFolderOptions update_device_preview_folder_options: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(DevicePreviewFolderDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'folder_id',
            'update_device_preview_folder_options'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

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

        collection_formats = {}

        path_params = {}
        if 'folder_id' in local_var_params:
            path_params['folderId'] = local_var_params['folder_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

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

        return self.api_client.call_api(
            '/emails/device-previews/folders/{folderId}', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DevicePreviewFolderDto',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def update_device_preview_profile(self, profile_id, update_device_preview_profile_options, **kwargs):  # noqa: E501
        """Update a device preview 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.update_device_preview_profile(profile_id, update_device_preview_profile_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str profile_id: (required)
        :param UpdateDevicePreviewProfileOptions update_device_preview_profile_options: (required)
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: DevicePreviewProfileDto
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.update_device_preview_profile_with_http_info(profile_id, update_device_preview_profile_options, **kwargs)  # noqa: E501

    def update_device_preview_profile_with_http_info(self, profile_id, update_device_preview_profile_options, **kwargs):  # noqa: E501
        """Update a device preview 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.update_device_preview_profile_with_http_info(profile_id, update_device_preview_profile_options, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str profile_id: (required)
        :param UpdateDevicePreviewProfileOptions update_device_preview_profile_options: (required)
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(DevicePreviewProfileDto, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'profile_id',
            'update_device_preview_profile_options'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

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

        collection_formats = {}

        path_params = {}
        if 'profile_id' in local_var_params:
            path_params['profileId'] = local_var_params['profile_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

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

        return self.api_client.call_api(
            '/emails/device-previews/profiles/{profileId}', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DevicePreviewProfileDto',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def wait_for_device_preview_email_runs(self, since, **kwargs):  # noqa: E501
        """Wait for device preview runs created from account email domains  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.wait_for_device_preview_email_runs(since, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param datetime since: (required)
        :param str email_domain_id:
        :param str profile_id:
        :param str local_part:
        :param int limit:
        :param int timeout_millis:
        :param int poll_interval_millis:
        :param bool hydrate_thumbnail: Hydrate each returned run with a nullable primary screenshot thumbnail URL.
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: DevicePreviewIngestRunWaitResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.wait_for_device_preview_email_runs_with_http_info(since, **kwargs)  # noqa: E501

    def wait_for_device_preview_email_runs_with_http_info(self, since, **kwargs):  # noqa: E501
        """Wait for device preview runs created from account email domains  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.wait_for_device_preview_email_runs_with_http_info(since, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param datetime since: (required)
        :param str email_domain_id:
        :param str profile_id:
        :param str local_part:
        :param int limit:
        :param int timeout_millis:
        :param int poll_interval_millis:
        :param bool hydrate_thumbnail: Hydrate each returned run with a nullable primary screenshot thumbnail URL.
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(DevicePreviewIngestRunWaitResult, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'since',
            'email_domain_id',
            'profile_id',
            'local_part',
            'limit',
            'timeout_millis',
            'poll_interval_millis',
            'hydrate_thumbnail'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

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

        if self.api_client.client_side_validation and 'limit' in local_var_params and local_var_params['limit'] > 100:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `limit` when calling `wait_for_device_preview_email_runs`, must be a value less than or equal to `100`")  # noqa: E501
        if self.api_client.client_side_validation and 'timeout_millis' in local_var_params and local_var_params['timeout_millis'] > 60000:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `timeout_millis` when calling `wait_for_device_preview_email_runs`, must be a value less than or equal to `60000`")  # noqa: E501
        if self.api_client.client_side_validation and 'timeout_millis' in local_var_params and local_var_params['timeout_millis'] < 1000:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `timeout_millis` when calling `wait_for_device_preview_email_runs`, must be a value greater than or equal to `1000`")  # noqa: E501
        if self.api_client.client_side_validation and 'poll_interval_millis' in local_var_params and local_var_params['poll_interval_millis'] > 10000:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `poll_interval_millis` when calling `wait_for_device_preview_email_runs`, must be a value less than or equal to `10000`")  # noqa: E501
        if self.api_client.client_side_validation and 'poll_interval_millis' in local_var_params and local_var_params['poll_interval_millis'] < 250:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `poll_interval_millis` when calling `wait_for_device_preview_email_runs`, must be a value greater than or equal to `250`")  # noqa: E501
        collection_formats = {}

        path_params = {}

        query_params = []
        if 'since' in local_var_params and local_var_params['since'] is not None:  # noqa: E501
            query_params.append(('since', local_var_params['since']))  # noqa: E501
        if 'email_domain_id' in local_var_params and local_var_params['email_domain_id'] is not None:  # noqa: E501
            query_params.append(('emailDomainId', local_var_params['email_domain_id']))  # noqa: E501
        if 'profile_id' in local_var_params and local_var_params['profile_id'] is not None:  # noqa: E501
            query_params.append(('profileId', local_var_params['profile_id']))  # noqa: E501
        if 'local_part' in local_var_params and local_var_params['local_part'] is not None:  # noqa: E501
            query_params.append(('localPart', local_var_params['local_part']))  # noqa: E501
        if 'limit' in local_var_params and local_var_params['limit'] is not None:  # noqa: E501
            query_params.append(('limit', local_var_params['limit']))  # noqa: E501
        if 'timeout_millis' in local_var_params and local_var_params['timeout_millis'] is not None:  # noqa: E501
            query_params.append(('timeoutMillis', local_var_params['timeout_millis']))  # noqa: E501
        if 'poll_interval_millis' in local_var_params and local_var_params['poll_interval_millis'] is not None:  # noqa: E501
            query_params.append(('pollIntervalMillis', local_var_params['poll_interval_millis']))  # noqa: E501
        if 'hydrate_thumbnail' in local_var_params and local_var_params['hydrate_thumbnail'] is not None:  # noqa: E501
            query_params.append(('hydrateThumbnail', local_var_params['hydrate_thumbnail']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        return self.api_client.call_api(
            '/emails/device-previews/email-runs/wait', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DevicePreviewIngestRunWaitResult',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def wait_for_device_preview_email_submissions(self, since, **kwargs):  # noqa: E501
        """Wait for received device preview email submissions  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.wait_for_device_preview_email_submissions(since, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param datetime since: (required)
        :param str email_domain_id:
        :param str profile_id:
        :param str local_part:
        :param int limit:
        :param int timeout_millis:
        :param int poll_interval_millis:
        :param str recipient_email_address:
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: DevicePreviewEmailSubmissionWaitResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.wait_for_device_preview_email_submissions_with_http_info(since, **kwargs)  # noqa: E501

    def wait_for_device_preview_email_submissions_with_http_info(self, since, **kwargs):  # noqa: E501
        """Wait for received device preview email submissions  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.wait_for_device_preview_email_submissions_with_http_info(since, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param datetime since: (required)
        :param str email_domain_id:
        :param str profile_id:
        :param str local_part:
        :param int limit:
        :param int timeout_millis:
        :param int poll_interval_millis:
        :param str recipient_email_address:
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(DevicePreviewEmailSubmissionWaitResult, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'since',
            'email_domain_id',
            'profile_id',
            'local_part',
            'limit',
            'timeout_millis',
            'poll_interval_millis',
            'recipient_email_address'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

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

        if self.api_client.client_side_validation and 'limit' in local_var_params and local_var_params['limit'] > 100:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `limit` when calling `wait_for_device_preview_email_submissions`, must be a value less than or equal to `100`")  # noqa: E501
        if self.api_client.client_side_validation and 'timeout_millis' in local_var_params and local_var_params['timeout_millis'] > 60000:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `timeout_millis` when calling `wait_for_device_preview_email_submissions`, must be a value less than or equal to `60000`")  # noqa: E501
        if self.api_client.client_side_validation and 'timeout_millis' in local_var_params and local_var_params['timeout_millis'] < 1000:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `timeout_millis` when calling `wait_for_device_preview_email_submissions`, must be a value greater than or equal to `1000`")  # noqa: E501
        if self.api_client.client_side_validation and 'poll_interval_millis' in local_var_params and local_var_params['poll_interval_millis'] > 10000:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `poll_interval_millis` when calling `wait_for_device_preview_email_submissions`, must be a value less than or equal to `10000`")  # noqa: E501
        if self.api_client.client_side_validation and 'poll_interval_millis' in local_var_params and local_var_params['poll_interval_millis'] < 250:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `poll_interval_millis` when calling `wait_for_device_preview_email_submissions`, must be a value greater than or equal to `250`")  # noqa: E501
        collection_formats = {}

        path_params = {}

        query_params = []
        if 'since' in local_var_params and local_var_params['since'] is not None:  # noqa: E501
            query_params.append(('since', local_var_params['since']))  # noqa: E501
        if 'email_domain_id' in local_var_params and local_var_params['email_domain_id'] is not None:  # noqa: E501
            query_params.append(('emailDomainId', local_var_params['email_domain_id']))  # noqa: E501
        if 'profile_id' in local_var_params and local_var_params['profile_id'] is not None:  # noqa: E501
            query_params.append(('profileId', local_var_params['profile_id']))  # noqa: E501
        if 'local_part' in local_var_params and local_var_params['local_part'] is not None:  # noqa: E501
            query_params.append(('localPart', local_var_params['local_part']))  # noqa: E501
        if 'limit' in local_var_params and local_var_params['limit'] is not None:  # noqa: E501
            query_params.append(('limit', local_var_params['limit']))  # noqa: E501
        if 'timeout_millis' in local_var_params and local_var_params['timeout_millis'] is not None:  # noqa: E501
            query_params.append(('timeoutMillis', local_var_params['timeout_millis']))  # noqa: E501
        if 'poll_interval_millis' in local_var_params and local_var_params['poll_interval_millis'] is not None:  # noqa: E501
            query_params.append(('pollIntervalMillis', local_var_params['poll_interval_millis']))  # noqa: E501
        if 'recipient_email_address' in local_var_params and local_var_params['recipient_email_address'] is not None:  # noqa: E501
            query_params.append(('recipientEmailAddress', local_var_params['recipient_email_address']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        return self.api_client.call_api(
            '/emails/device-previews/email-submissions/wait', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DevicePreviewEmailSubmissionWaitResult',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def wait_for_device_preview_run(self, run_id, **kwargs):  # noqa: E501
        """Wait for device preview run to complete  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.wait_for_device_preview_run(run_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str run_id: (required)
        :param int timeout_millis:
        :param int poll_interval_millis:
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: DevicePreviewRunWaitResult
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.wait_for_device_preview_run_with_http_info(run_id, **kwargs)  # noqa: E501

    def wait_for_device_preview_run_with_http_info(self, run_id, **kwargs):  # noqa: E501
        """Wait for device preview run to complete  # noqa: E501

        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.wait_for_device_preview_run_with_http_info(run_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str run_id: (required)
        :param int timeout_millis:
        :param int poll_interval_millis:
        :param _return_http_data_only: response data without head status code
                                       and headers
        :param _preload_content: if False, the urllib3.HTTPResponse object will
                                 be returned without reading/decoding response
                                 data. Default is True.
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :return: tuple(DevicePreviewRunWaitResult, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = [
            'run_id',
            'timeout_millis',
            'poll_interval_millis'
        ]
        all_params.extend(
            [
                'async_req',
                '_return_http_data_only',
                '_preload_content',
                '_request_timeout'
            ]
        )

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

        if self.api_client.client_side_validation and 'timeout_millis' in local_var_params and local_var_params['timeout_millis'] > 60000:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `timeout_millis` when calling `wait_for_device_preview_run`, must be a value less than or equal to `60000`")  # noqa: E501
        if self.api_client.client_side_validation and 'timeout_millis' in local_var_params and local_var_params['timeout_millis'] < 1000:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `timeout_millis` when calling `wait_for_device_preview_run`, must be a value greater than or equal to `1000`")  # noqa: E501
        if self.api_client.client_side_validation and 'poll_interval_millis' in local_var_params and local_var_params['poll_interval_millis'] > 10000:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `poll_interval_millis` when calling `wait_for_device_preview_run`, must be a value less than or equal to `10000`")  # noqa: E501
        if self.api_client.client_side_validation and 'poll_interval_millis' in local_var_params and local_var_params['poll_interval_millis'] < 250:  # noqa: E501
            raise ApiValueError("Invalid value for parameter `poll_interval_millis` when calling `wait_for_device_preview_run`, must be a value greater than or equal to `250`")  # noqa: E501
        collection_formats = {}

        path_params = {}
        if 'run_id' in local_var_params:
            path_params['runId'] = local_var_params['run_id']  # noqa: E501

        query_params = []
        if 'timeout_millis' in local_var_params and local_var_params['timeout_millis'] is not None:  # noqa: E501
            query_params.append(('timeoutMillis', local_var_params['timeout_millis']))  # noqa: E501
        if 'poll_interval_millis' in local_var_params and local_var_params['poll_interval_millis'] is not None:  # noqa: E501
            query_params.append(('pollIntervalMillis', local_var_params['poll_interval_millis']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        return self.api_client.call_api(
            '/emails/device-previews/{runId}/wait', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='DevicePreviewRunWaitResult',  # noqa: E501
            auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get('_return_http_data_only'),  # noqa: E501
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

Methods

def cancel_device_preview_run(self, run_id, **kwargs)

Cancel a running device preview run # 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_device_preview_run(run_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str run_id: (required) :param CancelDevicePreviewRunOptions cancel_device_preview_run_options: :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: CancelDevicePreviewRunResult If the method is called asynchronously, returns the request thread.

def cancel_device_preview_run_with_http_info(self, run_id, **kwargs)

Cancel a running device preview run # 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_device_preview_run_with_http_info(run_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str run_id: (required) :param CancelDevicePreviewRunOptions cancel_device_preview_run_options: :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(CancelDevicePreviewRunResult, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def create_device_preview_feedback(self, create_device_preview_feedback_options, **kwargs)

Create device preview feedback # 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_device_preview_feedback(create_device_preview_feedback_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param CreateDevicePreviewFeedbackOptions create_device_preview_feedback_options: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: DevicePreviewFeedbackDto If the method is called asynchronously, returns the request thread.

def create_device_preview_feedback_with_http_info(self, create_device_preview_feedback_options, **kwargs)

Create device preview feedback # 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_device_preview_feedback_with_http_info(create_device_preview_feedback_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param CreateDevicePreviewFeedbackOptions create_device_preview_feedback_options: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(DevicePreviewFeedbackDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def create_device_preview_folder(self, create_device_preview_folder_options, **kwargs)

Create a device preview folder # 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_device_preview_folder(create_device_preview_folder_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param CreateDevicePreviewFolderOptions create_device_preview_folder_options: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: DevicePreviewFolderDto If the method is called asynchronously, returns the request thread.

def create_device_preview_folder_with_http_info(self, create_device_preview_folder_options, **kwargs)

Create a device preview folder # 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_device_preview_folder_with_http_info(create_device_preview_folder_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param CreateDevicePreviewFolderOptions create_device_preview_folder_options: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(DevicePreviewFolderDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def create_device_preview_import_address(self, **kwargs)

Create a temporary email address for device preview import # 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_device_preview_import_address(async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param CreateDevicePreviewIngestAddressOptions create_device_preview_ingest_address_options: :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: DevicePreviewIngestAddressDto If the method is called asynchronously, returns the request thread.

def create_device_preview_import_address_with_http_info(self, **kwargs)

Create a temporary email address for device preview import # 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_device_preview_import_address_with_http_info(async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param CreateDevicePreviewIngestAddressOptions create_device_preview_ingest_address_options: :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(DevicePreviewIngestAddressDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def create_device_preview_profile(self, create_device_preview_profile_options, **kwargs)

Create a device preview 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.create_device_preview_profile(create_device_preview_profile_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param CreateDevicePreviewProfileOptions create_device_preview_profile_options: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: DevicePreviewProfileDto If the method is called asynchronously, returns the request thread.

def create_device_preview_profile_with_http_info(self, create_device_preview_profile_options, **kwargs)

Create a device preview 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.create_device_preview_profile_with_http_info(create_device_preview_profile_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param CreateDevicePreviewProfileOptions create_device_preview_profile_options: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(DevicePreviewProfileDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def create_device_preview_run(self, email_id, **kwargs)

Create a new device preview run for an email # 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_device_preview_run(email_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str email_id: (required) :param CreateDevicePreviewOptions create_device_preview_options: :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: CreateDevicePreviewRunResult If the method is called asynchronously, returns the request thread.

def create_device_preview_run_from_file(self, file, **kwargs)

Create a device preview run from an HTML, EML, or ZIP file # noqa: E501

Uploads an HTML or RFC822 EML file, or a ZIP archive containing exactly one HTML or EML file. ZIP uploads are bounded by entry count, expanded size, and compression ratio. # 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_device_preview_run_from_file(file, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param file file: An .html, .htm, or .eml file, or a .zip archive containing exactly one supported file. (required) :param str subject: :param str _from: :param str to: :param str source_alias: :param str external_id: :param list[str] providers: Legacy web-provider keys to render. :param bool all_targets: Render every currently configured target. :param list[str] targets: Device preview target keys to render. :param bool email_audit: :param bool domain_monitor: :param str sender_domain: :param str folder_id: :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: CreateDevicePreviewRunResult If the method is called asynchronously, returns the request thread.

def create_device_preview_run_from_file_with_http_info(self, file, **kwargs)

Create a device preview run from an HTML, EML, or ZIP file # noqa: E501

Uploads an HTML or RFC822 EML file, or a ZIP archive containing exactly one HTML or EML file. ZIP uploads are bounded by entry count, expanded size, and compression ratio. # 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_device_preview_run_from_file_with_http_info(file, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param file file: An .html, .htm, or .eml file, or a .zip archive containing exactly one supported file. (required) :param str subject: :param str _from: :param str to: :param str source_alias: :param str external_id: :param list[str] providers: Legacy web-provider keys to render. :param bool all_targets: Render every currently configured target. :param list[str] targets: Device preview target keys to render. :param bool email_audit: :param bool domain_monitor: :param str sender_domain: :param str folder_id: :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(CreateDevicePreviewRunResult, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def create_device_preview_run_from_html_import(self, create_device_preview_html_import_options, **kwargs)

Create a device preview run from HTML # 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_device_preview_run_from_html_import(create_device_preview_html_import_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param CreateDevicePreviewHtmlImportOptions create_device_preview_html_import_options: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: CreateDevicePreviewRunResult If the method is called asynchronously, returns the request thread.

def create_device_preview_run_from_html_import_with_http_info(self, create_device_preview_html_import_options, **kwargs)

Create a device preview run from HTML # 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_device_preview_run_from_html_import_with_http_info(create_device_preview_html_import_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param CreateDevicePreviewHtmlImportOptions create_device_preview_html_import_options: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(CreateDevicePreviewRunResult, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def create_device_preview_run_from_import(self, create_device_preview_import_options, **kwargs)

Create a device preview run from imported raw MIME # 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_device_preview_run_from_import(create_device_preview_import_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param CreateDevicePreviewImportOptions create_device_preview_import_options: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: CreateDevicePreviewRunResult If the method is called asynchronously, returns the request thread.

def create_device_preview_run_from_import_with_http_info(self, create_device_preview_import_options, **kwargs)

Create a device preview run from imported raw MIME # 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_device_preview_run_from_import_with_http_info(create_device_preview_import_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param CreateDevicePreviewImportOptions create_device_preview_import_options: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(CreateDevicePreviewRunResult, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def create_device_preview_run_from_multipart_import(self, file, **kwargs)

Create a device preview run from multipart EML upload # 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_device_preview_run_from_multipart_import(file, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param file file: (required) :param str source_alias: :param str external_id: :param bool all_targets: Render every currently configured target. :param list[str] targets: Device preview target keys to render. :param str folder_id: :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: CreateDevicePreviewRunResult If the method is called asynchronously, returns the request thread.

def create_device_preview_run_from_multipart_import_with_http_info(self, file, **kwargs)

Create a device preview run from multipart EML upload # 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_device_preview_run_from_multipart_import_with_http_info(file, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param file file: (required) :param str source_alias: :param str external_id: :param bool all_targets: Render every currently configured target. :param list[str] targets: Device preview target keys to render. :param str folder_id: :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(CreateDevicePreviewRunResult, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def create_device_preview_run_from_raw_import(self, **kwargs)

Create a device preview run from raw MIME bytes # 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_device_preview_run_from_raw_import(async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str source_alias: :param str external_id: :param bool all_targets: Render every currently configured target. :param list[str] targets: Device preview target keys to render. :param str folder_id: :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: CreateDevicePreviewRunResult If the method is called asynchronously, returns the request thread.

def create_device_preview_run_from_raw_import_with_http_info(self, **kwargs)

Create a device preview run from raw MIME bytes # 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_device_preview_run_from_raw_import_with_http_info(async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str source_alias: :param str external_id: :param bool all_targets: Render every currently configured target. :param list[str] targets: Device preview target keys to render. :param str folder_id: :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(CreateDevicePreviewRunResult, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def create_device_preview_run_with_http_info(self, email_id, **kwargs)

Create a new device preview run for an email # 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_device_preview_run_with_http_info(email_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str email_id: (required) :param CreateDevicePreviewOptions create_device_preview_options: :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(CreateDevicePreviewRunResult, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def create_device_preview_share_link(self, run_id, **kwargs)

Create a share link for a device preview run # 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_device_preview_share_link(run_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str run_id: (required) :param CreateDevicePreviewShareLinkOptions create_device_preview_share_link_options: :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: DevicePreviewShareLinkDto If the method is called asynchronously, returns the request thread.

def create_device_preview_share_link_with_http_info(self, run_id, **kwargs)

Create a share link for a device preview run # 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_device_preview_share_link_with_http_info(run_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str run_id: (required) :param CreateDevicePreviewShareLinkOptions create_device_preview_share_link_options: :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(DevicePreviewShareLinkDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def delete_device_preview_folder(self, folder_id, **kwargs)

Delete a folder, preserving renders and child folders # 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_device_preview_folder(folder_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str folder_id: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: DeleteDevicePreviewFolderResult If the method is called asynchronously, returns the request thread.

def delete_device_preview_folder_with_http_info(self, folder_id, **kwargs)

Delete a folder, preserving renders and child folders # 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_device_preview_folder_with_http_info(folder_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str folder_id: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(DeleteDevicePreviewFolderResult, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def delete_device_preview_profile(self, profile_id, **kwargs)

Delete a device preview 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.delete_device_preview_profile(profile_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str profile_id: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: DeleteDevicePreviewProfileResult If the method is called asynchronously, returns the request thread.

def delete_device_preview_profile_with_http_info(self, profile_id, **kwargs)

Delete a device preview 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.delete_device_preview_profile_with_http_info(profile_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str profile_id: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(DeleteDevicePreviewProfileResult, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def delete_device_preview_run(self, run_id, **kwargs)

Delete local device preview run data # 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_device_preview_run(run_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str run_id: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: DeleteDevicePreviewRunResult If the method is called asynchronously, returns the request thread.

def delete_device_preview_run_with_http_info(self, run_id, **kwargs)

Delete local device preview run data # 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_device_preview_run_with_http_info(run_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str run_id: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(DeleteDevicePreviewRunResult, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def delete_device_preview_share_link(self, share_link_id, **kwargs)

Revoke a device preview share link # 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_device_preview_share_link(share_link_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str share_link_id: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: DeleteDevicePreviewShareLinkResult If the method is called asynchronously, returns the request thread.

def delete_device_preview_share_link_with_http_info(self, share_link_id, **kwargs)

Revoke a device preview share link # 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_device_preview_share_link_with_http_info(share_link_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str share_link_id: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(DeleteDevicePreviewShareLinkResult, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def download_device_preview_email_submission_source_email(self, submission_id, **kwargs)

Download the original RFC822 email for a device preview submission # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.download_device_preview_email_submission_source_email(submission_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str submission_id: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: file If the method is called asynchronously, returns the request thread.

def download_device_preview_email_submission_source_email_with_http_info(self, submission_id, **kwargs)

Download the original RFC822 email for a device preview submission # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.download_device_preview_email_submission_source_email_with_http_info(submission_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str submission_id: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(file, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def download_device_preview_run_source_email(self, run_id, **kwargs)

Download the original RFC822 email for a device preview run # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.download_device_preview_run_source_email(run_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str run_id: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: file If the method is called asynchronously, returns the request thread.

def download_device_preview_run_source_email_with_http_info(self, run_id, **kwargs)

Download the original RFC822 email for a device preview run # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.download_device_preview_run_source_email_with_http_info(run_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str run_id: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(file, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def ensure_device_preview_run(self, email_id, **kwargs)

Return active run for email or create one when none exists # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.ensure_device_preview_run(email_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str email_id: (required) :param CreateDevicePreviewOptions create_device_preview_options: :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: CreateDevicePreviewRunResult If the method is called asynchronously, returns the request thread.

def ensure_device_preview_run_with_http_info(self, email_id, **kwargs)

Return active run for email or create one when none exists # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.ensure_device_preview_run_with_http_info(email_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str email_id: (required) :param CreateDevicePreviewOptions create_device_preview_options: :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(CreateDevicePreviewRunResult, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def get_device_preview_email_domain_or_create(self, **kwargs)

Return account device preview email domain setup or create one # 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_device_preview_email_domain_or_create(async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: DevicePreviewAccountSettingsDto If the method is called asynchronously, returns the request thread.

def get_device_preview_email_domain_or_create_with_http_info(self, **kwargs)

Return account device preview email domain setup or create one # 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_device_preview_email_domain_or_create_with_http_info(async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(DevicePreviewAccountSettingsDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def get_device_preview_email_runs(self, since, **kwargs)

List device preview runs created from account email domains # 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_device_preview_email_runs(since, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param datetime since: (required) :param str email_domain_id: :param str profile_id: :param str local_part: :param int limit: :param bool hydrate_thumbnail: Hydrate each returned run with a nullable primary screenshot thumbnail URL. :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: list[DevicePreviewRunDto] If the method is called asynchronously, returns the request thread.

def get_device_preview_email_runs_with_http_info(self, since, **kwargs)

List device preview runs created from account email domains # 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_device_preview_email_runs_with_http_info(since, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param datetime since: (required) :param str email_domain_id: :param str profile_id: :param str local_part: :param int limit: :param bool hydrate_thumbnail: Hydrate each returned run with a nullable primary screenshot thumbnail URL. :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(list[DevicePreviewRunDto], status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def get_device_preview_email_submission_source_email(self, submission_id, **kwargs)

Get the original email content for a device preview submission # 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_device_preview_email_submission_source_email(submission_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str submission_id: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: DevicePreviewSourceEmailDto If the method is called asynchronously, returns the request thread.

def get_device_preview_email_submission_source_email_with_http_info(self, submission_id, **kwargs)

Get the original email content for a device preview submission # 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_device_preview_email_submission_source_email_with_http_info(submission_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str submission_id: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(DevicePreviewSourceEmailDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def get_device_preview_email_submissions(self, since, **kwargs)

List received device preview email submissions # 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_device_preview_email_submissions(since, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param datetime since: (required) :param str email_domain_id: :param str profile_id: :param str local_part: :param int limit: :param str recipient_email_address: :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: list[DevicePreviewEmailSubmissionDto] If the method is called asynchronously, returns the request thread.

def get_device_preview_email_submissions_with_http_info(self, since, **kwargs)

List received device preview email submissions # 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_device_preview_email_submissions_with_http_info(since, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param datetime since: (required) :param str email_domain_id: :param str profile_id: :param str local_part: :param int limit: :param str recipient_email_address: :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(list[DevicePreviewEmailSubmissionDto], status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def get_device_preview_feedback(self, feedback_id, **kwargs)

Get a single device preview feedback item # 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_device_preview_feedback(feedback_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str feedback_id: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: DevicePreviewFeedbackDto If the method is called asynchronously, returns the request thread.

def get_device_preview_feedback_items(self, **kwargs)

List device preview feedback # 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_device_preview_feedback_items(async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param int page: :param int size: :param str source: :param str run_id: :param str status: :param str provider: :param str category: :param str search: :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: DevicePreviewFeedbackListDto If the method is called asynchronously, returns the request thread.

def get_device_preview_feedback_items_with_http_info(self, **kwargs)

List device preview feedback # 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_device_preview_feedback_items_with_http_info(async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param int page: :param int size: :param str source: :param str run_id: :param str status: :param str provider: :param str category: :param str search: :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(DevicePreviewFeedbackListDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def get_device_preview_feedback_with_http_info(self, feedback_id, **kwargs)

Get a single device preview feedback item # 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_device_preview_feedback_with_http_info(feedback_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str feedback_id: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(DevicePreviewFeedbackDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def get_device_preview_folder(self, folder_id, **kwargs)

Get a device preview folder # 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_device_preview_folder(folder_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str folder_id: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: DevicePreviewFolderDto If the method is called asynchronously, returns the request thread.

def get_device_preview_folder_with_http_info(self, folder_id, **kwargs)

Get a device preview folder # 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_device_preview_folder_with_http_info(folder_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str folder_id: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(DevicePreviewFolderDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def get_device_preview_folders(self, **kwargs)

List device preview folders # 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_device_preview_folders(async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: list[DevicePreviewFolderDto] If the method is called asynchronously, returns the request thread.

def get_device_preview_folders_with_http_info(self, **kwargs)

List device preview folders # 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_device_preview_folders_with_http_info(async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(list[DevicePreviewFolderDto], status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def get_device_preview_import_address(self, session_id, **kwargs)

Get temporary device preview import address status # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

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

:param async_req bool: execute request asynchronously :param str session_id: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: DevicePreviewIngestAddressDto If the method is called asynchronously, returns the request thread.

def get_device_preview_import_address_with_http_info(self, session_id, **kwargs)

Get temporary device preview import address status # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

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

:param async_req bool: execute request asynchronously :param str session_id: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(DevicePreviewIngestAddressDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def get_device_preview_native_target_availability(self, **kwargs)

Get native device preview target availability # noqa: E501

Returns live native device preview target availability for authenticated API clients, including worker health, queue, timeout, and status fields. Use /device-preview-targets when you need the stable catalog without transient availability data. # 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_device_preview_native_target_availability(async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: DevicePreviewNativeTargetAvailabilityListDto If the method is called asynchronously, returns the request thread.

def get_device_preview_native_target_availability_with_http_info(self, **kwargs)

Get native device preview target availability # noqa: E501

Returns live native device preview target availability for authenticated API clients, including worker health, queue, timeout, and status fields. Use /device-preview-targets when you need the stable catalog without transient availability data. # 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_device_preview_native_target_availability_with_http_info(async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(DevicePreviewNativeTargetAvailabilityListDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def get_device_preview_profile(self, profile_id, **kwargs)

Get a device preview 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.get_device_preview_profile(profile_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str profile_id: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: DevicePreviewProfileDto If the method is called asynchronously, returns the request thread.

def get_device_preview_profile_with_http_info(self, profile_id, **kwargs)

Get a device preview 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.get_device_preview_profile_with_http_info(profile_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str profile_id: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(DevicePreviewProfileDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def get_device_preview_profiles(self, **kwargs)

List device preview profiles # 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_device_preview_profiles(async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: list[DevicePreviewProfileDto] If the method is called asynchronously, returns the request thread.

def get_device_preview_profiles_with_http_info(self, **kwargs)

List device preview profiles # 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_device_preview_profiles_with_http_info(async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(list[DevicePreviewProfileDto], status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def get_device_preview_run(self, run_id, **kwargs)

Get device preview run status # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.get_device_preview_run(run_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str run_id: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: DevicePreviewRunDto If the method is called asynchronously, returns the request thread.

def get_device_preview_run_provider_progress(self, run_id, provider, **kwargs)

Get provider-level progress for a device preview run # 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_device_preview_run_provider_progress(run_id, provider, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str run_id: (required) :param str provider: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: DevicePreviewProviderProgressDto If the method is called asynchronously, returns the request thread.

def get_device_preview_run_provider_progress_with_http_info(self, run_id, provider, **kwargs)

Get provider-level progress for a device preview run # 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_device_preview_run_provider_progress_with_http_info(run_id, provider, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str run_id: (required) :param str provider: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(DevicePreviewProviderProgressDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def get_device_preview_run_results(self, run_id, **kwargs)

Get device preview run results # 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_device_preview_run_results(run_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str run_id: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: DevicePreviewRunResultsDto If the method is called asynchronously, returns the request thread.

def get_device_preview_run_results_with_http_info(self, run_id, **kwargs)

Get device preview run results # 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_device_preview_run_results_with_http_info(run_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str run_id: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(DevicePreviewRunResultsDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def get_device_preview_run_screenshot(self, run_id, screenshot_id, **kwargs)

Get a device preview screenshot image # 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_device_preview_run_screenshot(run_id, screenshot_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str run_id: (required) :param str screenshot_id: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: str If the method is called asynchronously, returns the request thread.

def get_device_preview_run_screenshot_with_http_info(self, run_id, screenshot_id, **kwargs)

Get a device preview screenshot image # 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_device_preview_run_screenshot_with_http_info(run_id, screenshot_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str run_id: (required) :param str screenshot_id: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(str, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def get_device_preview_run_source_email(self, run_id, **kwargs)

Get the original email content for a device preview run # 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_device_preview_run_source_email(run_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str run_id: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: DevicePreviewSourceEmailDto If the method is called asynchronously, returns the request thread.

def get_device_preview_run_source_email_with_http_info(self, run_id, **kwargs)

Get the original email content for a device preview run # 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_device_preview_run_source_email_with_http_info(run_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str run_id: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(DevicePreviewSourceEmailDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def get_device_preview_run_with_http_info(self, run_id, **kwargs)

Get device preview run status # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.get_device_preview_run_with_http_info(run_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str run_id: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(DevicePreviewRunDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def get_device_preview_runs(self, email_id, **kwargs)

List previous device preview runs for an email # 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_device_preview_runs(email_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str email_id: (required) :param int limit: :param bool hydrate_thumbnail: Hydrate each returned run with a nullable primary screenshot thumbnail URL. :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: list[DevicePreviewRunDto] If the method is called asynchronously, returns the request thread.

def get_device_preview_runs_for_account(self, **kwargs)

List previous device preview runs for account # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

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

:param async_req bool: execute request asynchronously :param int limit: :param bool hydrate_thumbnail: Hydrate each returned run with a nullable primary screenshot thumbnail URL. :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: list[DevicePreviewRunDto] If the method is called asynchronously, returns the request thread.

def get_device_preview_runs_for_account_offset_paginated(self, **kwargs)

List previous device preview runs for account in paginated form # 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_device_preview_runs_for_account_offset_paginated(async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param int page: Optional page index in list pagination :param int size: Optional page size for paginated result list. :param str sort: Optional createdAt sort direction ASC or DESC :param bool hydrate_thumbnail: Hydrate each returned run with a nullable primary screenshot thumbnail URL. :param str folder_id: :param bool unfiled_only: :param str email_id: :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: PageDevicePreviewRunProjection If the method is called asynchronously, returns the request thread.

def get_device_preview_runs_for_account_offset_paginated_with_http_info(self, **kwargs)

List previous device preview runs for account in paginated form # 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_device_preview_runs_for_account_offset_paginated_with_http_info(async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param int page: Optional page index in list pagination :param int size: Optional page size for paginated result list. :param str sort: Optional createdAt sort direction ASC or DESC :param bool hydrate_thumbnail: Hydrate each returned run with a nullable primary screenshot thumbnail URL. :param str folder_id: :param bool unfiled_only: :param str email_id: :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(PageDevicePreviewRunProjection, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def get_device_preview_runs_for_account_with_http_info(self, **kwargs)

List previous device preview runs for account # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

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

:param async_req bool: execute request asynchronously :param int limit: :param bool hydrate_thumbnail: Hydrate each returned run with a nullable primary screenshot thumbnail URL. :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(list[DevicePreviewRunDto], status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def get_device_preview_runs_offset_paginated(self, email_id, **kwargs)

List previous device preview runs for an email in paginated form # 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_device_preview_runs_offset_paginated(email_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str email_id: (required) :param int page: Optional page index in list pagination :param int size: Optional page size for paginated result list. :param str sort: Optional createdAt sort direction ASC or DESC :param bool hydrate_thumbnail: Hydrate each returned run with a nullable primary screenshot thumbnail URL. :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: PageDevicePreviewRunProjection If the method is called asynchronously, returns the request thread.

def get_device_preview_runs_offset_paginated_with_http_info(self, email_id, **kwargs)

List previous device preview runs for an email in paginated form # 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_device_preview_runs_offset_paginated_with_http_info(email_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str email_id: (required) :param int page: Optional page index in list pagination :param int size: Optional page size for paginated result list. :param str sort: Optional createdAt sort direction ASC or DESC :param bool hydrate_thumbnail: Hydrate each returned run with a nullable primary screenshot thumbnail URL. :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(PageDevicePreviewRunProjection, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def get_device_preview_runs_with_http_info(self, email_id, **kwargs)

List previous device preview runs for an email # 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_device_preview_runs_with_http_info(email_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str email_id: (required) :param int limit: :param bool hydrate_thumbnail: Hydrate each returned run with a nullable primary screenshot thumbnail URL. :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(list[DevicePreviewRunDto], status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def get_device_preview_share_links(self, run_id, **kwargs)

List share links for a device preview run # 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_device_preview_share_links(run_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str run_id: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: list[DevicePreviewShareLinkDto] If the method is called asynchronously, returns the request thread.

def get_device_preview_share_links_with_http_info(self, run_id, **kwargs)

List share links for a device preview run # 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_device_preview_share_links_with_http_info(run_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str run_id: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(list[DevicePreviewShareLinkDto], status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def get_device_preview_shared_result(self, share_token, **kwargs)

Get a public shared device preview result # 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_device_preview_shared_result(share_token, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str share_token: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: DevicePreviewSharedResultDto If the method is called asynchronously, returns the request thread.

def get_device_preview_shared_result_screenshot(self, share_token, screenshot_id, **kwargs)

Get a public shared device preview screenshot image # 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_device_preview_shared_result_screenshot(share_token, screenshot_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str share_token: (required) :param str screenshot_id: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: str If the method is called asynchronously, returns the request thread.

def get_device_preview_shared_result_screenshot_with_http_info(self, share_token, screenshot_id, **kwargs)

Get a public shared device preview screenshot image # 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_device_preview_shared_result_screenshot_with_http_info(share_token, screenshot_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str share_token: (required) :param str screenshot_id: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(str, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def get_device_preview_shared_result_with_http_info(self, share_token, **kwargs)

Get a public shared device preview result # 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_device_preview_shared_result_with_http_info(share_token, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str share_token: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(DevicePreviewSharedResultDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def get_device_preview_targets(self, **kwargs)

List device preview targets # noqa: E501

Returns visible native device preview target metadata without worker availability, queue, or health fields. # 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_device_preview_targets(async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: DevicePreviewNativeTargetListDto If the method is called asynchronously, returns the request thread.

def get_device_preview_targets_with_http_info(self, **kwargs)

List device preview targets # noqa: E501

Returns visible native device preview target metadata without worker availability, queue, or health fields. # 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_device_preview_targets_with_http_info(async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(DevicePreviewNativeTargetListDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def move_device_preview_runs(self, move_device_preview_runs_options, **kwargs)

Move device preview runs to a folder or Unfiled # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.move_device_preview_runs(move_device_preview_runs_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param MoveDevicePreviewRunsOptions move_device_preview_runs_options: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: MoveDevicePreviewRunsResult If the method is called asynchronously, returns the request thread.

def move_device_preview_runs_with_http_info(self, move_device_preview_runs_options, **kwargs)

Move device preview runs to a folder or Unfiled # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.move_device_preview_runs_with_http_info(move_device_preview_runs_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param MoveDevicePreviewRunsOptions move_device_preview_runs_options: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(MoveDevicePreviewRunsResult, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def rerun_device_preview_targets(self, run_id, rerun_device_preview_targets_options, **kwargs)

Rerun selected device preview targets in the same run # noqa: E501

Set failedOnly=false to rerun a successful target. Successful targets consume their configured credit cost again. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.rerun_device_preview_targets(run_id, rerun_device_preview_targets_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str run_id: (required) :param RerunDevicePreviewTargetsOptions rerun_device_preview_targets_options: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: RerunDevicePreviewTargetsResult If the method is called asynchronously, returns the request thread.

def rerun_device_preview_targets_with_http_info(self, run_id, rerun_device_preview_targets_options, **kwargs)

Rerun selected device preview targets in the same run # noqa: E501

Set failedOnly=false to rerun a successful target. Successful targets consume their configured credit cost again. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.rerun_device_preview_targets_with_http_info(run_id, rerun_device_preview_targets_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str run_id: (required) :param RerunDevicePreviewTargetsOptions rerun_device_preview_targets_options: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(RerunDevicePreviewTargetsResult, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def update_device_preview_email_domain_subdomain(self, update_device_preview_ingest_domain_options, **kwargs)

Update account device preview email subdomain # 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_device_preview_email_domain_subdomain(update_device_preview_ingest_domain_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param UpdateDevicePreviewIngestDomainOptions update_device_preview_ingest_domain_options: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: DevicePreviewAccountSettingsDto If the method is called asynchronously, returns the request thread.

def update_device_preview_email_domain_subdomain_with_http_info(self, update_device_preview_ingest_domain_options, **kwargs)

Update account device preview email subdomain # 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_device_preview_email_domain_subdomain_with_http_info(update_device_preview_ingest_domain_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param UpdateDevicePreviewIngestDomainOptions update_device_preview_ingest_domain_options: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(DevicePreviewAccountSettingsDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def update_device_preview_feedback(self, feedback_id, update_device_preview_feedback_options, **kwargs)

Update device preview feedback # 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_device_preview_feedback(feedback_id, update_device_preview_feedback_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str feedback_id: (required) :param UpdateDevicePreviewFeedbackOptions update_device_preview_feedback_options: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: DevicePreviewFeedbackDto If the method is called asynchronously, returns the request thread.

def update_device_preview_feedback_with_http_info(self, feedback_id, update_device_preview_feedback_options, **kwargs)

Update device preview feedback # 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_device_preview_feedback_with_http_info(feedback_id, update_device_preview_feedback_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str feedback_id: (required) :param UpdateDevicePreviewFeedbackOptions update_device_preview_feedback_options: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(DevicePreviewFeedbackDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def update_device_preview_folder(self, folder_id, update_device_preview_folder_options, **kwargs)

Rename or move a device preview folder # 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_device_preview_folder(folder_id, update_device_preview_folder_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str folder_id: (required) :param UpdateDevicePreviewFolderOptions update_device_preview_folder_options: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: DevicePreviewFolderDto If the method is called asynchronously, returns the request thread.

def update_device_preview_folder_with_http_info(self, folder_id, update_device_preview_folder_options, **kwargs)

Rename or move a device preview folder # 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_device_preview_folder_with_http_info(folder_id, update_device_preview_folder_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str folder_id: (required) :param UpdateDevicePreviewFolderOptions update_device_preview_folder_options: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(DevicePreviewFolderDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def update_device_preview_profile(self, profile_id, update_device_preview_profile_options, **kwargs)

Update a device preview 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.update_device_preview_profile(profile_id, update_device_preview_profile_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str profile_id: (required) :param UpdateDevicePreviewProfileOptions update_device_preview_profile_options: (required) :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: DevicePreviewProfileDto If the method is called asynchronously, returns the request thread.

def update_device_preview_profile_with_http_info(self, profile_id, update_device_preview_profile_options, **kwargs)

Update a device preview 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.update_device_preview_profile_with_http_info(profile_id, update_device_preview_profile_options, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str profile_id: (required) :param UpdateDevicePreviewProfileOptions update_device_preview_profile_options: (required) :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(DevicePreviewProfileDto, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def wait_for_device_preview_email_runs(self, since, **kwargs)

Wait for device preview runs created from account email domains # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.wait_for_device_preview_email_runs(since, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param datetime since: (required) :param str email_domain_id: :param str profile_id: :param str local_part: :param int limit: :param int timeout_millis: :param int poll_interval_millis: :param bool hydrate_thumbnail: Hydrate each returned run with a nullable primary screenshot thumbnail URL. :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: DevicePreviewIngestRunWaitResult If the method is called asynchronously, returns the request thread.

def wait_for_device_preview_email_runs_with_http_info(self, since, **kwargs)

Wait for device preview runs created from account email domains # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.wait_for_device_preview_email_runs_with_http_info(since, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param datetime since: (required) :param str email_domain_id: :param str profile_id: :param str local_part: :param int limit: :param int timeout_millis: :param int poll_interval_millis: :param bool hydrate_thumbnail: Hydrate each returned run with a nullable primary screenshot thumbnail URL. :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(DevicePreviewIngestRunWaitResult, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def wait_for_device_preview_email_submissions(self, since, **kwargs)

Wait for received device preview email submissions # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.wait_for_device_preview_email_submissions(since, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param datetime since: (required) :param str email_domain_id: :param str profile_id: :param str local_part: :param int limit: :param int timeout_millis: :param int poll_interval_millis: :param str recipient_email_address: :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: DevicePreviewEmailSubmissionWaitResult If the method is called asynchronously, returns the request thread.

def wait_for_device_preview_email_submissions_with_http_info(self, since, **kwargs)

Wait for received device preview email submissions # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.wait_for_device_preview_email_submissions_with_http_info(since, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param datetime since: (required) :param str email_domain_id: :param str profile_id: :param str local_part: :param int limit: :param int timeout_millis: :param int poll_interval_millis: :param str recipient_email_address: :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(DevicePreviewEmailSubmissionWaitResult, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.

def wait_for_device_preview_run(self, run_id, **kwargs)

Wait for device preview run to complete # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.wait_for_device_preview_run(run_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str run_id: (required) :param int timeout_millis: :param int poll_interval_millis: :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: DevicePreviewRunWaitResult If the method is called asynchronously, returns the request thread.

def wait_for_device_preview_run_with_http_info(self, run_id, **kwargs)

Wait for device preview run to complete # noqa: E501

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True

>>> thread = api.wait_for_device_preview_run_with_http_info(run_id, async_req=True)
>>> result = thread.get()

:param async_req bool: execute request asynchronously :param str run_id: (required) :param int timeout_millis: :param int poll_interval_millis: :param _return_http_data_only: response data without head status code and headers :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :return: tuple(DevicePreviewRunWaitResult, status_code(int), headers(HTTPHeaderDict)) If the method is called asynchronously, returns the request thread.