# coding: utf-8
from __future__ import absolute_import

"""
   Copyright 2020 Jackpine Technologies Corporation

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
"""
"""
cons3rt - Copyright Jackpine Technologies Corp.

NOTE: This file is auto-generated. Do not edit the file manually.
"""


from __future__ import absolute_import

import re  # noqa: F401

# python 2 and python 3 compatibility library
import six

from cons3rt.api_client import ApiClient
from cons3rt.exceptions import (
    ApiTypeError,
    ApiValueError
)

__author__ = 'Jackpine Technologies Corporation'
__copyright__ = 'Copyright 2020, Jackpine Technologies Corporation'
__license__ = 'Apache 2.0',
__version__ = '1.0.0'
__maintainer__ = 'API Support'
__email__ = 'support@cons3rt.com'


class VirtualizationRealmsApi(object):
    """NOTE: This class is auto-generated. 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 add_network(self, id, abstract_add_network_cloud_space_request, **kwargs):  # noqa: E501
        """Allocate Network  # noqa: E501

        Adds a Network to the specified Virtualization Realm.<br> <br> Since this call results in the construction of a new, back-end Network it has financial implications and should not be used if the user is not prepared to incur the expense of construction and existence of the newly created Network.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.add_network(id, abstract_add_network_cloud_space_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param AbstractAddNetworkCloudSpaceRequest abstract_add_network_cloud_space_request: The network allocation information (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: MinimalVirtualizationRealm
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.add_network_with_http_info(id, abstract_add_network_cloud_space_request, **kwargs)  # noqa: E501

    def add_network_with_http_info(self, id, abstract_add_network_cloud_space_request, **kwargs):  # noqa: E501
        """Allocate Network  # noqa: E501

        Adds a Network to the specified Virtualization Realm.<br> <br> Since this call results in the construction of a new, back-end Network it has financial implications and should not be used if the user is not prepared to incur the expense of construction and existence of the newly created Network.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.add_network_with_http_info(id, abstract_add_network_cloud_space_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param AbstractAddNetworkCloudSpaceRequest abstract_add_network_cloud_space_request: The network allocation information (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(MinimalVirtualizationRealm, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id', 'abstract_add_network_cloud_space_request']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 add_network" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `add_network`")  # noqa: E501
        # verify the required parameter 'abstract_add_network_cloud_space_request' is set
        if self.api_client.client_side_validation and ('abstract_add_network_cloud_space_request' not in local_var_params or  # noqa: E501
                                                        local_var_params['abstract_add_network_cloud_space_request'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `abstract_add_network_cloud_space_request` when calling `add_network`")  # noqa: E501

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/networks', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='MinimalVirtualizationRealm',  # 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 add_project(self, id, project_id, **kwargs):  # noqa: E501
        """Assign Project  # noqa: E501

        Provides members of the Project with access to the specified Virtualization Realm  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.add_project(id, project_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param str project_id: ID of project to assign (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: int
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.add_project_with_http_info(id, project_id, **kwargs)  # noqa: E501

    def add_project_with_http_info(self, id, project_id, **kwargs):  # noqa: E501
        """Assign Project  # noqa: E501

        Provides members of the Project with access to the specified Virtualization Realm  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.add_project_with_http_info(id, project_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param str project_id: ID of project to assign (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(int, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id', 'project_id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 add_project" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `add_project`")  # noqa: E501
        # verify the required parameter 'project_id' is set
        if self.api_client.client_side_validation and ('project_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['project_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `project_id` when calling `add_project`")  # noqa: E501

        collection_formats = {}

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

        query_params = []
        if 'project_id' in local_var_params and local_var_params['project_id'] is not None:  # noqa: E501
            query_params.append(('projectId', local_var_params['project_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(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/projects', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='int',  # 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_template_subsciption(self, id, registration_id, **kwargs):  # noqa: E501
        """Create Template Subscription  # noqa: E501

        Creates a Template Subscription in the specified Virtualization Realm.  # 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_template_subsciption(id, registration_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (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: FullTemplateSubscription
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.create_template_subsciption_with_http_info(id, registration_id, **kwargs)  # noqa: E501

    def create_template_subsciption_with_http_info(self, id, registration_id, **kwargs):  # noqa: E501
        """Create Template Subscription  # noqa: E501

        Creates a Template Subscription in the specified Virtualization Realm.  # 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_template_subsciption_with_http_info(id, registration_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (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(FullTemplateSubscription, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id', 'registration_id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_template_subsciption" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `create_template_subsciption`")  # noqa: E501
        # verify the required parameter 'registration_id' is set
        if self.api_client.client_side_validation and ('registration_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['registration_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `registration_id` when calling `create_template_subsciption`")  # noqa: E501

        collection_formats = {}

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

        query_params = []
        if 'registration_id' in local_var_params and local_var_params['registration_id'] is not None:  # noqa: E501
            query_params.append(('registration_id', local_var_params['registration_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(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/subscriptions', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='FullTemplateSubscription',  # 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_network(self, id, network_id, **kwargs):  # noqa: E501
        """Delete Network  # noqa: E501

        Removes an existing Network from the specified Virtualization Realm.  # 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_network(id, network_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param int network_id: ID of network (required)
        :param bool deallocate: Attempt to delete all back-end resources
        :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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.delete_network_with_http_info(id, network_id, **kwargs)  # noqa: E501

    def delete_network_with_http_info(self, id, network_id, **kwargs):  # noqa: E501
        """Delete Network  # noqa: E501

        Removes an existing Network from the specified Virtualization Realm.  # 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_network_with_http_info(id, network_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param int network_id: ID of network (required)
        :param bool deallocate: Attempt to delete all back-end resources
        :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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id', 'network_id', 'deallocate']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_network" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `delete_network`")  # noqa: E501
        # verify the required parameter 'network_id' is set
        if self.api_client.client_side_validation and ('network_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['network_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `network_id` when calling `delete_network`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501
        if 'network_id' in local_var_params:
            path_params['networkId'] = local_var_params['network_id']  # noqa: E501

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

        header_params = {}

        form_params = []
        local_var_files = {}

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

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/networks/{networkId}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='bool',  # 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_template_subscription(self, id, subscription_id, **kwargs):  # noqa: E501
        """Delete Template Subscription  # noqa: E501

        Removes an existing Template Subscription from the specified Virtualization Realm.  # 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_template_subscription(id, subscription_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int subscription_id: ID of template subscription (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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.delete_template_subscription_with_http_info(id, subscription_id, **kwargs)  # noqa: E501

    def delete_template_subscription_with_http_info(self, id, subscription_id, **kwargs):  # noqa: E501
        """Delete Template Subscription  # noqa: E501

        Removes an existing Template Subscription from the specified Virtualization Realm.  # 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_template_subscription_with_http_info(id, subscription_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int subscription_id: ID of template subscription (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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id', 'subscription_id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_template_subscription" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `delete_template_subscription`")  # noqa: E501
        # verify the required parameter 'subscription_id' is set
        if self.api_client.client_side_validation and ('subscription_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['subscription_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `subscription_id` when calling `delete_template_subscription`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501
        if 'subscription_id' in local_var_params:
            path_params['subscription_id'] = local_var_params['subscription_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(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/subscriptions/{subscription_id}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='bool',  # 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 disable_virt_realm_remote_access(self, id, **kwargs):  # noqa: E501
        """Disable Remote Access  # noqa: E501

        Disables Remote Access for a single Virtualization Realm by the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.disable_virt_realm_remote_access(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.disable_virt_realm_remote_access_with_http_info(id, **kwargs)  # noqa: E501

    def disable_virt_realm_remote_access_with_http_info(self, id, **kwargs):  # noqa: E501
        """Disable Remote Access  # noqa: E501

        Disables Remote Access for a single Virtualization Realm by the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.disable_virt_realm_remote_access_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 disable_virt_realm_remote_access" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `disable_virt_realm_remote_access`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['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(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/remoteaccess', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='bool',  # 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 enable_maintence_mode1(self, id, **kwargs):  # noqa: E501
        """Update Maintenance Mode  # noqa: E501

        Updates the maintenance status for a single Virtualization Realm by the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.enable_maintence_mode1(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param bool enable: Enable or disable maintenance mode
        :param MaintenanceModeRequest maintenance_mode_request: The maintenance mode request, when enabling maintenance mode
        :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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.enable_maintence_mode1_with_http_info(id, **kwargs)  # noqa: E501

    def enable_maintence_mode1_with_http_info(self, id, **kwargs):  # noqa: E501
        """Update Maintenance Mode  # noqa: E501

        Updates the maintenance status for a single Virtualization Realm by the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.enable_maintence_mode1_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param bool enable: Enable or disable maintenance mode
        :param MaintenanceModeRequest maintenance_mode_request: The maintenance mode request, when enabling maintenance mode
        :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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id', 'enable', 'maintenance_mode_request']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 enable_maintence_mode1" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `enable_maintence_mode1`")  # noqa: E501

        collection_formats = {}

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

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

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/maintenance', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='bool',  # 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 enable_virt_realm_remote_access(self, id, **kwargs):  # noqa: E501
        """Enable Remote Access  # noqa: E501

        Enables Remote Access for a single Virtualization Realm by the given ID.<br> <br> To do so, Remote Access must be configured for the Virtualization Realm.<br> <br> If no instanceType is provided, the Instance Type will first attempt to use the value from the Virtualization Realm's Remote Access config.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.enable_virt_realm_remote_access(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param str instance_type: Remote access server instance type
        :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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.enable_virt_realm_remote_access_with_http_info(id, **kwargs)  # noqa: E501

    def enable_virt_realm_remote_access_with_http_info(self, id, **kwargs):  # noqa: E501
        """Enable Remote Access  # noqa: E501

        Enables Remote Access for a single Virtualization Realm by the given ID.<br> <br> To do so, Remote Access must be configured for the Virtualization Realm.<br> <br> If no instanceType is provided, the Instance Type will first attempt to use the value from the Virtualization Realm's Remote Access config.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.enable_virt_realm_remote_access_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param str instance_type: Remote access server instance type
        :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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id', 'instance_type']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 enable_virt_realm_remote_access" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `enable_virt_realm_remote_access`")  # noqa: E501

        collection_formats = {}

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

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

        header_params = {}

        form_params = []
        local_var_files = {}

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

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/remoteaccess', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='bool',  # 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_deployment_runs_in_virtualization_realm(self, id, search_type, **kwargs):  # noqa: E501
        """List Deployment Runs  # noqa: E501

        Returns a collection of the Deployment Runs launched into the specified Virtualization Realm.  # 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_deployment_runs_in_virtualization_realm(id, search_type, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param str search_type: Deployment run status type (required)
        :param int maxresults: Maximum number of results to return
        :param int page: Requested page number
        :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[MinimalDeploymentRun]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_deployment_runs_in_virtualization_realm_with_http_info(id, search_type, **kwargs)  # noqa: E501

    def get_deployment_runs_in_virtualization_realm_with_http_info(self, id, search_type, **kwargs):  # noqa: E501
        """List Deployment Runs  # noqa: E501

        Returns a collection of the Deployment Runs launched into the specified Virtualization Realm.  # 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_deployment_runs_in_virtualization_realm_with_http_info(id, search_type, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param str search_type: Deployment run status type (required)
        :param int maxresults: Maximum number of results to return
        :param int page: Requested page number
        :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[MinimalDeploymentRun], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id', 'search_type', 'maxresults', 'page']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_deployment_runs_in_virtualization_realm" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `get_deployment_runs_in_virtualization_realm`")  # noqa: E501
        # verify the required parameter 'search_type' is set
        if self.api_client.client_side_validation and ('search_type' not in local_var_params or  # noqa: E501
                                                        local_var_params['search_type'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `search_type` when calling `get_deployment_runs_in_virtualization_realm`")  # noqa: E501

        collection_formats = {}

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

        query_params = []
        if 'search_type' in local_var_params and local_var_params['search_type'] is not None:  # noqa: E501
            query_params.append(('search_type', local_var_params['search_type']))  # noqa: E501
        if 'maxresults' in local_var_params and local_var_params['maxresults'] is not None:  # noqa: E501
            query_params.append(('maxresults', local_var_params['maxresults']))  # noqa: E501
        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

        header_params = {}

        form_params = []
        local_var_files = {}

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

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/deploymentruns', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[MinimalDeploymentRun]',  # 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_host_configuration_metrics1(self, id, start, end, **kwargs):  # noqa: E501
        """Retrieve Metrics  # noqa: E501

        Returns metric data for Deployment Runs launched into the specified Virtualization Realm.  # 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_host_configuration_metrics1(id, start, end, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param int start: Interval start time, specified in seconds since epoch (required)
        :param int end: Interval end time, specified in seconds since epoch (required)
        :param int interval: Number of intervals
        :param str interval_unit: Interval unit
        :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_host_configuration_metrics1_with_http_info(id, start, end, **kwargs)  # noqa: E501

    def get_host_configuration_metrics1_with_http_info(self, id, start, end, **kwargs):  # noqa: E501
        """Retrieve Metrics  # noqa: E501

        Returns metric data for Deployment Runs launched into the specified Virtualization Realm.  # 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_host_configuration_metrics1_with_http_info(id, start, end, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param int start: Interval start time, specified in seconds since epoch (required)
        :param int end: Interval end time, specified in seconds since epoch (required)
        :param int interval: Number of intervals
        :param str interval_unit: Interval unit
        :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 = ['id', 'start', 'end', 'interval', 'interval_unit']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_host_configuration_metrics1" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `get_host_configuration_metrics1`")  # noqa: E501
        # verify the required parameter 'start' is set
        if self.api_client.client_side_validation and ('start' not in local_var_params or  # noqa: E501
                                                        local_var_params['start'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `start` when calling `get_host_configuration_metrics1`")  # noqa: E501
        # verify the required parameter 'end' is set
        if self.api_client.client_side_validation and ('end' not in local_var_params or  # noqa: E501
                                                        local_var_params['end'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `end` when calling `get_host_configuration_metrics1`")  # noqa: E501

        collection_formats = {}

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

        query_params = []
        if 'start' in local_var_params and local_var_params['start'] is not None:  # noqa: E501
            query_params.append(('start', local_var_params['start']))  # noqa: E501
        if 'end' in local_var_params and local_var_params['end'] is not None:  # noqa: E501
            query_params.append(('end', local_var_params['end']))  # noqa: E501
        if 'interval' in local_var_params and local_var_params['interval'] is not None:  # noqa: E501
            query_params.append(('interval', local_var_params['interval']))  # noqa: E501
        if 'interval_unit' in local_var_params and local_var_params['interval_unit'] is not None:  # noqa: E501
            query_params.append(('intervalUnit', local_var_params['interval_unit']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

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

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/metrics/hostconfiguration', '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_network(self, id, network_id, **kwargs):  # noqa: E501
        """Retrieve Network  # noqa: E501

        Returns a single Network in the specified Virtualization Realm.  # 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_network(id, network_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param int network_id: ID of network (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: Network
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_network_with_http_info(id, network_id, **kwargs)  # noqa: E501

    def get_network_with_http_info(self, id, network_id, **kwargs):  # noqa: E501
        """Retrieve Network  # noqa: E501

        Returns a single Network in the specified Virtualization Realm.  # 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_network_with_http_info(id, network_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param int network_id: ID of network (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(Network, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id', 'network_id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_network" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `get_network`")  # noqa: E501
        # verify the required parameter 'network_id' is set
        if self.api_client.client_side_validation and ('network_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['network_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `network_id` when calling `get_network`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501
        if 'network_id' in local_var_params:
            path_params['networkId'] = local_var_params['network_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(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/networks/{networkId}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='Network',  # 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_networks(self, id, **kwargs):  # noqa: E501
        """List Networks  # noqa: E501

        Returns a collection of the Networks in the specified Virtualization Realm.  # 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_networks(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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[MinimalNetwork]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_networks_with_http_info(id, **kwargs)  # noqa: E501

    def get_networks_with_http_info(self, id, **kwargs):  # noqa: E501
        """List Networks  # noqa: E501

        Returns a collection of the Networks in the specified Virtualization Realm.  # 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_networks_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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[MinimalNetwork], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_networks" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `get_networks`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['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(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/networks', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[MinimalNetwork]',  # 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_template_subscription(self, id, subscription_id, **kwargs):  # noqa: E501
        """Retrieve Template Subscription  # noqa: E501

        Returns a single Template Subscription in the specified Virtualization Realm.  # 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_template_subscription(id, subscription_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int subscription_id: ID of template subscription (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: FullTemplateSubscription
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_template_subscription_with_http_info(id, subscription_id, **kwargs)  # noqa: E501

    def get_template_subscription_with_http_info(self, id, subscription_id, **kwargs):  # noqa: E501
        """Retrieve Template Subscription  # noqa: E501

        Returns a single Template Subscription in the specified Virtualization Realm.  # 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_template_subscription_with_http_info(id, subscription_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int subscription_id: ID of template subscription (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(FullTemplateSubscription, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id', 'subscription_id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_template_subscription" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `get_template_subscription`")  # noqa: E501
        # verify the required parameter 'subscription_id' is set
        if self.api_client.client_side_validation and ('subscription_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['subscription_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `subscription_id` when calling `get_template_subscription`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501
        if 'subscription_id' in local_var_params:
            path_params['subscription_id'] = local_var_params['subscription_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(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/subscriptions/{subscription_id}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='FullTemplateSubscription',  # 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_templates_in_virtualization_realm(self, id, **kwargs):  # noqa: E501
        """List Templates  # noqa: E501

        Returns a collection of the Templates in the specified Virtualization Realm.  # 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_templates_in_virtualization_realm(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param bool include_registrations: Include templates registered to the virtualization realm
        :param bool include_subscriptions: Include templates subscribed to by the virtualization realm
        :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[MinimalCons3rtTemplateData]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_templates_in_virtualization_realm_with_http_info(id, **kwargs)  # noqa: E501

    def get_templates_in_virtualization_realm_with_http_info(self, id, **kwargs):  # noqa: E501
        """List Templates  # noqa: E501

        Returns a collection of the Templates in the specified Virtualization Realm.  # 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_templates_in_virtualization_realm_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param bool include_registrations: Include templates registered to the virtualization realm
        :param bool include_subscriptions: Include templates subscribed to by the virtualization realm
        :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[MinimalCons3rtTemplateData], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id', 'include_registrations', 'include_subscriptions']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_templates_in_virtualization_realm" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `get_templates_in_virtualization_realm`")  # noqa: E501

        collection_formats = {}

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

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

        header_params = {}

        form_params = []
        local_var_files = {}

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

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[MinimalCons3rtTemplateData]',  # 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_unregistered_networks(self, id, **kwargs):  # noqa: E501
        """List Unregistered Networks  # noqa: E501

        Returns a collection of the unregistered, back-end Networks in the specified Virtualization Realm.  # 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_unregistered_networks(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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[Subnet]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_unregistered_networks_with_http_info(id, **kwargs)  # noqa: E501

    def get_unregistered_networks_with_http_info(self, id, **kwargs):  # noqa: E501
        """List Unregistered Networks  # noqa: E501

        Returns a collection of the unregistered, back-end Networks in the specified Virtualization Realm.  # 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_unregistered_networks_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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[Subnet], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_unregistered_networks" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `get_unregistered_networks`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['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(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/networks/unregistered', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[Subnet]',  # 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_virtual_machine_count_metrics1(self, id, start, end, **kwargs):  # noqa: E501
        """Retrieve Virtual Machine Metrics  # noqa: E501

        Returns metric data for Virtual Machines launched into the specified Virtualization Realm.  # 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_virtual_machine_count_metrics1(id, start, end, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param int start: Interval start time, specified in seconds since epoch (required)
        :param int end: Interval end time, specified in seconds since epoch (required)
        :param int interval: Number of intervals
        :param str interval_unit: Interval unit
        :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_virtual_machine_count_metrics1_with_http_info(id, start, end, **kwargs)  # noqa: E501

    def get_virtual_machine_count_metrics1_with_http_info(self, id, start, end, **kwargs):  # noqa: E501
        """Retrieve Virtual Machine Metrics  # noqa: E501

        Returns metric data for Virtual Machines launched into the specified Virtualization Realm.  # 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_virtual_machine_count_metrics1_with_http_info(id, start, end, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param int start: Interval start time, specified in seconds since epoch (required)
        :param int end: Interval end time, specified in seconds since epoch (required)
        :param int interval: Number of intervals
        :param str interval_unit: Interval unit
        :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 = ['id', 'start', 'end', 'interval', 'interval_unit']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_virtual_machine_count_metrics1" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `get_virtual_machine_count_metrics1`")  # noqa: E501
        # verify the required parameter 'start' is set
        if self.api_client.client_side_validation and ('start' not in local_var_params or  # noqa: E501
                                                        local_var_params['start'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `start` when calling `get_virtual_machine_count_metrics1`")  # noqa: E501
        # verify the required parameter 'end' is set
        if self.api_client.client_side_validation and ('end' not in local_var_params or  # noqa: E501
                                                        local_var_params['end'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `end` when calling `get_virtual_machine_count_metrics1`")  # noqa: E501

        collection_formats = {}

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

        query_params = []
        if 'start' in local_var_params and local_var_params['start'] is not None:  # noqa: E501
            query_params.append(('start', local_var_params['start']))  # noqa: E501
        if 'end' in local_var_params and local_var_params['end'] is not None:  # noqa: E501
            query_params.append(('end', local_var_params['end']))  # noqa: E501
        if 'interval' in local_var_params and local_var_params['interval'] is not None:  # noqa: E501
            query_params.append(('interval', local_var_params['interval']))  # noqa: E501
        if 'interval_unit' in local_var_params and local_var_params['interval_unit'] is not None:  # noqa: E501
            query_params.append(('intervalUnit', local_var_params['interval_unit']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

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

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/metrics/virtualmachinecount', '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_virtualization_realm(self, id, **kwargs):  # noqa: E501
        """Retrieve Virtualization Realm  # noqa: E501

        Returns a single Virtualization Realm by the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_virtualization_realm(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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: FullVirtualizationRealm
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_virtualization_realm_with_http_info(id, **kwargs)  # noqa: E501

    def get_virtualization_realm_with_http_info(self, id, **kwargs):  # noqa: E501
        """Retrieve Virtualization Realm  # noqa: E501

        Returns a single Virtualization Realm by the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_virtualization_realm_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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(FullVirtualizationRealm, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_virtualization_realm" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `get_virtualization_realm`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['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(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='FullVirtualizationRealm',  # 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_virtualization_realm_resources(self, id, **kwargs):  # noqa: E501
        """Retrieve Virtualization Realm Resources  # noqa: E501

        Returns the back-end resources for a single Virtualization Realm by the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_virtualization_realm_resources(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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: AbstractCloudResources
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_virtualization_realm_resources_with_http_info(id, **kwargs)  # noqa: E501

    def get_virtualization_realm_resources_with_http_info(self, id, **kwargs):  # noqa: E501
        """Retrieve Virtualization Realm Resources  # noqa: E501

        Returns the back-end resources for a single Virtualization Realm by the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_virtualization_realm_resources_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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(AbstractCloudResources, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_virtualization_realm_resources" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `get_virtualization_realm_resources`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['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(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/resources', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='AbstractCloudResources',  # 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_virtualization_realms(self, **kwargs):  # noqa: E501
        """List Virtualization Realms  # noqa: E501

        Returns a collection of the Virtualization Realms that the user manages.  # 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_virtualization_realms(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int maxresults: Maximum number of results to return
        :param int page: Requested page number
        :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[MinimalVirtualizationRealm]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_virtualization_realms_with_http_info(**kwargs)  # noqa: E501

    def get_virtualization_realms_with_http_info(self, **kwargs):  # noqa: E501
        """List Virtualization Realms  # noqa: E501

        Returns a collection of the Virtualization Realms that the user manages.  # 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_virtualization_realms_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int maxresults: Maximum number of results to return
        :param int page: Requested page number
        :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[MinimalVirtualizationRealm], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['maxresults', 'page']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_virtualization_realms" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'maxresults' in local_var_params and local_var_params['maxresults'] is not None:  # noqa: E501
            query_params.append(('maxresults', local_var_params['maxresults']))  # noqa: E501
        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

        header_params = {}

        form_params = []
        local_var_files = {}

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

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[MinimalVirtualizationRealm]',  # 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 invalidate_template_cache_in_virtualization_realm(self, id, **kwargs):  # noqa: E501
        """Refresh Template Cache  # noqa: E501

        Forces the back-end Template data to be re-read in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.invalidate_template_cache_in_virtualization_realm(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.invalidate_template_cache_in_virtualization_realm_with_http_info(id, **kwargs)  # noqa: E501

    def invalidate_template_cache_in_virtualization_realm_with_http_info(self, id, **kwargs):  # noqa: E501
        """Refresh Template Cache  # noqa: E501

        Forces the back-end Template data to be re-read in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.invalidate_template_cache_in_virtualization_realm_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 invalidate_template_cache_in_virtualization_realm" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `invalidate_template_cache_in_virtualization_realm`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['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(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/registrations', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='bool',  # 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 list_pending_template_subscriptions(self, id, **kwargs):  # noqa: E501
        """List Pending Subscriptions  # noqa: E501

        Returns a collection of the pending Template Subscriptions in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_pending_template_subscriptions(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (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[FullTemplateRegistrationForSubscription]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.list_pending_template_subscriptions_with_http_info(id, **kwargs)  # noqa: E501

    def list_pending_template_subscriptions_with_http_info(self, id, **kwargs):  # noqa: E501
        """List Pending Subscriptions  # noqa: E501

        Returns a collection of the pending Template Subscriptions in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_pending_template_subscriptions_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (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[FullTemplateRegistrationForSubscription], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 list_pending_template_subscriptions" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `list_pending_template_subscriptions`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['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(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/subscriptions/pending', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[FullTemplateRegistrationForSubscription]',  # 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 list_projects(self, id, **kwargs):  # noqa: E501
        """List Projects  # noqa: E501

        Returns a collection of the Projects allowed to access to the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_projects(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param int maxresults: Maximum number of results to return
        :param int page: Requested page number
        :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[MinimalProject]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.list_projects_with_http_info(id, **kwargs)  # noqa: E501

    def list_projects_with_http_info(self, id, **kwargs):  # noqa: E501
        """List Projects  # noqa: E501

        Returns a collection of the Projects allowed to access to the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_projects_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param int maxresults: Maximum number of results to return
        :param int page: Requested page number
        :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[MinimalProject], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id', 'maxresults', 'page']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 list_projects" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `list_projects`")  # noqa: E501

        collection_formats = {}

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

        query_params = []
        if 'maxresults' in local_var_params and local_var_params['maxresults'] is not None:  # noqa: E501
            query_params.append(('maxresults', local_var_params['maxresults']))  # noqa: E501
        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

        header_params = {}

        form_params = []
        local_var_files = {}

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

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/projects', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[MinimalProject]',  # 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 list_template_registrations(self, id, **kwargs):  # noqa: E501
        """List Template Registrations  # noqa: E501

        Returns a collection of the Template Registrations in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_template_registrations(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (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[MinimalTemplateRegistration]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.list_template_registrations_with_http_info(id, **kwargs)  # noqa: E501

    def list_template_registrations_with_http_info(self, id, **kwargs):  # noqa: E501
        """List Template Registrations  # noqa: E501

        Returns a collection of the Template Registrations in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_template_registrations_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (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[MinimalTemplateRegistration], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 list_template_registrations" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `list_template_registrations`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['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(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/registrations', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[MinimalTemplateRegistration]',  # 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 list_template_subscriptions(self, id, **kwargs):  # noqa: E501
        """List Template Subscriptions  # noqa: E501

        Returns a collection of the Template Subscriptions in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_template_subscriptions(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (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[MinimalTemplateSubscription]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.list_template_subscriptions_with_http_info(id, **kwargs)  # noqa: E501

    def list_template_subscriptions_with_http_info(self, id, **kwargs):  # noqa: E501
        """List Template Subscriptions  # noqa: E501

        Returns a collection of the Template Subscriptions in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_template_subscriptions_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (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[MinimalTemplateSubscription], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 list_template_subscriptions" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `list_template_subscriptions`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['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(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/subscriptions', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[MinimalTemplateSubscription]',  # 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 list_unregistered_templates(self, id, **kwargs):  # noqa: E501
        """List Unregistered Templates  # noqa: E501

        Returns a collection of the unregistered, back-end Templates in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_unregistered_templates(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (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[Cons3rtTemplateTagData]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.list_unregistered_templates_with_http_info(id, **kwargs)  # noqa: E501

    def list_unregistered_templates_with_http_info(self, id, **kwargs):  # noqa: E501
        """List Unregistered Templates  # noqa: E501

        Returns a collection of the unregistered, back-end Templates in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_unregistered_templates_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (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[Cons3rtTemplateTagData], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 list_unregistered_templates" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `list_unregistered_templates`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['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(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/registrations/pending', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[Cons3rtTemplateTagData]',  # 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 register_network(self, id, network_identifier, **kwargs):  # noqa: E501
        """Register Network  # noqa: E501

        Adds an existing, back-end Network the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.register_network(id, network_identifier, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param str network_identifier: Back-end network identifier (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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.register_network_with_http_info(id, network_identifier, **kwargs)  # noqa: E501

    def register_network_with_http_info(self, id, network_identifier, **kwargs):  # noqa: E501
        """Register Network  # noqa: E501

        Adds an existing, back-end Network the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.register_network_with_http_info(id, network_identifier, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param str network_identifier: Back-end network identifier (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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id', 'network_identifier']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 register_network" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `register_network`")  # noqa: E501
        # verify the required parameter 'network_identifier' is set
        if self.api_client.client_side_validation and ('network_identifier' not in local_var_params or  # noqa: E501
                                                        local_var_params['network_identifier'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `network_identifier` when calling `register_network`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501
        if 'network_identifier' in local_var_params:
            path_params['networkIdentifier'] = local_var_params['network_identifier']  # 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(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/networks/{networkIdentifier}', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='bool',  # 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 register_template(self, id, **kwargs):  # noqa: E501
        """Register Template  # noqa: E501

        Adds an existing back-end Template to the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.register_template(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param InputRegisterTemplateObject input_register_template_object: The template registration data
        :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: FullTemplateRegistration
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.register_template_with_http_info(id, **kwargs)  # noqa: E501

    def register_template_with_http_info(self, id, **kwargs):  # noqa: E501
        """Register Template  # noqa: E501

        Adds an existing back-end Template to the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.register_template_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param InputRegisterTemplateObject input_register_template_object: The template registration data
        :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(FullTemplateRegistration, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id', 'input_register_template_object']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 register_template" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `register_template`")  # noqa: E501

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/registrations', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='FullTemplateRegistration',  # 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 remove_project(self, id, project_id, **kwargs):  # noqa: E501
        """Unassign Project  # noqa: E501

        Revokes Project member access to the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.remove_project(id, project_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param str project_id: ID of project to unassign (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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.remove_project_with_http_info(id, project_id, **kwargs)  # noqa: E501

    def remove_project_with_http_info(self, id, project_id, **kwargs):  # noqa: E501
        """Unassign Project  # noqa: E501

        Revokes Project member access to the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.remove_project_with_http_info(id, project_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param str project_id: ID of project to unassign (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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id', 'project_id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 remove_project" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `remove_project`")  # noqa: E501
        # verify the required parameter 'project_id' is set
        if self.api_client.client_side_validation and ('project_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['project_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `project_id` when calling `remove_project`")  # noqa: E501

        collection_formats = {}

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

        query_params = []
        if 'project_id' in local_var_params and local_var_params['project_id'] is not None:  # noqa: E501
            query_params.append(('projectId', local_var_params['project_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(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/projects', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='bool',  # 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 retrieve_template_registration(self, id, registration_id, **kwargs):  # noqa: E501
        """Retrieve Template Registration  # noqa: E501

        Returns a single Template Registration in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_template_registration(id, registration_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (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: FullTemplateRegistration
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.retrieve_template_registration_with_http_info(id, registration_id, **kwargs)  # noqa: E501

    def retrieve_template_registration_with_http_info(self, id, registration_id, **kwargs):  # noqa: E501
        """Retrieve Template Registration  # noqa: E501

        Returns a single Template Registration in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_template_registration_with_http_info(id, registration_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (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(FullTemplateRegistration, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id', 'registration_id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 retrieve_template_registration" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `retrieve_template_registration`")  # noqa: E501
        # verify the required parameter 'registration_id' is set
        if self.api_client.client_side_validation and ('registration_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['registration_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `registration_id` when calling `retrieve_template_registration`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501
        if 'registration_id' in local_var_params:
            path_params['registration_id'] = local_var_params['registration_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(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/registrations/{registration_id}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='FullTemplateRegistration',  # 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 set_virtualization_realm_active(self, id, activate, **kwargs):  # noqa: E501
        """Update State  # noqa: E501

        Updates the active State for a single Virtualization Realm by the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.set_virtualization_realm_active(id, activate, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param bool activate: Activate or deactivate virtualization realm (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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.set_virtualization_realm_active_with_http_info(id, activate, **kwargs)  # noqa: E501

    def set_virtualization_realm_active_with_http_info(self, id, activate, **kwargs):  # noqa: E501
        """Update State  # noqa: E501

        Updates the active State for a single Virtualization Realm by the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.set_virtualization_realm_active_with_http_info(id, activate, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param bool activate: Activate or deactivate virtualization realm (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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id', 'activate']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 set_virtualization_realm_active" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `set_virtualization_realm_active`")  # noqa: E501
        # verify the required parameter 'activate' is set
        if self.api_client.client_side_validation and ('activate' not in local_var_params or  # noqa: E501
                                                        local_var_params['activate'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `activate` when calling `set_virtualization_realm_active`")  # noqa: E501

        collection_formats = {}

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

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

        header_params = {}

        form_params = []
        local_var_files = {}

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

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/activate', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='bool',  # 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 share_template_registration(self, id, registration_id, target_realm_ids, **kwargs):  # noqa: E501
        """Share Template  # noqa: E501

        Shares an existing Template Registration in the specified Virtualization Realm to the provided external Virtualization Realm(s).  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.share_template_registration(id, registration_id, target_realm_ids, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (required)
        :param list[int] target_realm_ids: ID(s) of external virtualization realms to share template registration with (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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.share_template_registration_with_http_info(id, registration_id, target_realm_ids, **kwargs)  # noqa: E501

    def share_template_registration_with_http_info(self, id, registration_id, target_realm_ids, **kwargs):  # noqa: E501
        """Share Template  # noqa: E501

        Shares an existing Template Registration in the specified Virtualization Realm to the provided external Virtualization Realm(s).  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.share_template_registration_with_http_info(id, registration_id, target_realm_ids, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (required)
        :param list[int] target_realm_ids: ID(s) of external virtualization realms to share template registration with (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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id', 'registration_id', 'target_realm_ids']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 share_template_registration" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `share_template_registration`")  # noqa: E501
        # verify the required parameter 'registration_id' is set
        if self.api_client.client_side_validation and ('registration_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['registration_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `registration_id` when calling `share_template_registration`")  # noqa: E501
        # verify the required parameter 'target_realm_ids' is set
        if self.api_client.client_side_validation and ('target_realm_ids' not in local_var_params or  # noqa: E501
                                                        local_var_params['target_realm_ids'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `target_realm_ids` when calling `share_template_registration`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501
        if 'registration_id' in local_var_params:
            path_params['registration_id'] = local_var_params['registration_id']  # noqa: E501

        query_params = []
        if 'target_realm_ids' in local_var_params and local_var_params['target_realm_ids'] is not None:  # noqa: E501
            query_params.append(('target_realm_ids', local_var_params['target_realm_ids']))  # noqa: E501
            collection_formats['target_realm_ids'] = 'multi'  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

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

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/registrations/{registration_id}/share', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='bool',  # 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 unregister_template(self, id, registration_id, input_unregister_template_object, **kwargs):  # noqa: E501
        """Delete Template Registration  # noqa: E501

        Removes an existing Template Registration from the specified Virtualization Realm.<br> <br> Note: Unregistering a Template will remove all subscriptions to the Template from other Virtualization Realms.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.unregister_template(id, registration_id, input_unregister_template_object, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (required)
        :param InputUnregisterTemplateObject input_unregister_template_object: The deletion settings (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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.unregister_template_with_http_info(id, registration_id, input_unregister_template_object, **kwargs)  # noqa: E501

    def unregister_template_with_http_info(self, id, registration_id, input_unregister_template_object, **kwargs):  # noqa: E501
        """Delete Template Registration  # noqa: E501

        Removes an existing Template Registration from the specified Virtualization Realm.<br> <br> Note: Unregistering a Template will remove all subscriptions to the Template from other Virtualization Realms.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.unregister_template_with_http_info(id, registration_id, input_unregister_template_object, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (required)
        :param InputUnregisterTemplateObject input_unregister_template_object: The deletion settings (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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id', 'registration_id', 'input_unregister_template_object']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 unregister_template" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `unregister_template`")  # noqa: E501
        # verify the required parameter 'registration_id' is set
        if self.api_client.client_side_validation and ('registration_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['registration_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `registration_id` when calling `unregister_template`")  # noqa: E501
        # verify the required parameter 'input_unregister_template_object' is set
        if self.api_client.client_side_validation and ('input_unregister_template_object' not in local_var_params or  # noqa: E501
                                                        local_var_params['input_unregister_template_object'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `input_unregister_template_object` when calling `unregister_template`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501
        if 'registration_id' in local_var_params:
            path_params['registration_id'] = local_var_params['registration_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/registrations/{registration_id}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='bool',  # 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 unshare_template_registration(self, id, registration_id, target_realm_id, **kwargs):  # noqa: E501
        """Unshare Template  # noqa: E501

        Revokes access to a Template Registration in the specified Virtualization Realm by the provided external Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.unshare_template_registration(id, registration_id, target_realm_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (required)
        :param int target_realm_id: ID of external virtualization realm to revoke template registration access for (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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.unshare_template_registration_with_http_info(id, registration_id, target_realm_id, **kwargs)  # noqa: E501

    def unshare_template_registration_with_http_info(self, id, registration_id, target_realm_id, **kwargs):  # noqa: E501
        """Unshare Template  # noqa: E501

        Revokes access to a Template Registration in the specified Virtualization Realm by the provided external Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.unshare_template_registration_with_http_info(id, registration_id, target_realm_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (required)
        :param int target_realm_id: ID of external virtualization realm to revoke template registration access for (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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id', 'registration_id', 'target_realm_id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 unshare_template_registration" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `unshare_template_registration`")  # noqa: E501
        # verify the required parameter 'registration_id' is set
        if self.api_client.client_side_validation and ('registration_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['registration_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `registration_id` when calling `unshare_template_registration`")  # noqa: E501
        # verify the required parameter 'target_realm_id' is set
        if self.api_client.client_side_validation and ('target_realm_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['target_realm_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `target_realm_id` when calling `unshare_template_registration`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501
        if 'registration_id' in local_var_params:
            path_params['registration_id'] = local_var_params['registration_id']  # noqa: E501

        query_params = []
        if 'target_realm_id' in local_var_params and local_var_params['target_realm_id'] is not None:  # noqa: E501
            query_params.append(('target_realm_id', local_var_params['target_realm_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(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/registrations/{registration_id}/share', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='bool',  # 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_template_registration(self, id, registration_id, input_cons3rt_template_data, **kwargs):  # noqa: E501
        """Update Template Registration  # noqa: E501

        Updates the Template Registration for a single Virtualization Realm by the given ID.<br> <br> Note: The state of a Template Registration can only be set to OFFLINE or PUBLISHED.<br> <br> Note: All fields in Template data are honored on update, therefore any configuration that is desired in the updated Registration should be provided.  # 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_template_registration(id, registration_id, input_cons3rt_template_data, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (required)
        :param InputCons3rtTemplateData input_cons3rt_template_data: The modified template registration data (required)
        :param bool offline: The desired template registration state
        :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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.update_template_registration_with_http_info(id, registration_id, input_cons3rt_template_data, **kwargs)  # noqa: E501

    def update_template_registration_with_http_info(self, id, registration_id, input_cons3rt_template_data, **kwargs):  # noqa: E501
        """Update Template Registration  # noqa: E501

        Updates the Template Registration for a single Virtualization Realm by the given ID.<br> <br> Note: The state of a Template Registration can only be set to OFFLINE or PUBLISHED.<br> <br> Note: All fields in Template data are honored on update, therefore any configuration that is desired in the updated Registration should be provided.  # 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_template_registration_with_http_info(id, registration_id, input_cons3rt_template_data, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (required)
        :param InputCons3rtTemplateData input_cons3rt_template_data: The modified template registration data (required)
        :param bool offline: The desired template registration state
        :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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id', 'registration_id', 'input_cons3rt_template_data', 'offline']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_template_registration" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `update_template_registration`")  # noqa: E501
        # verify the required parameter 'registration_id' is set
        if self.api_client.client_side_validation and ('registration_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['registration_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `registration_id` when calling `update_template_registration`")  # noqa: E501
        # verify the required parameter 'input_cons3rt_template_data' is set
        if self.api_client.client_side_validation and ('input_cons3rt_template_data' not in local_var_params or  # noqa: E501
                                                        local_var_params['input_cons3rt_template_data'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `input_cons3rt_template_data` when calling `update_template_registration`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501
        if 'registration_id' in local_var_params:
            path_params['registration_id'] = local_var_params['registration_id']  # noqa: E501

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

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/registrations/{registration_id}', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='bool',  # 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_template_subscription(self, id, subscription_id, input_template_subscription, **kwargs):  # noqa: E501
        """Update Template Subscription  # noqa: E501

        Updates the Template Subscription for a single Virtualization Realm by the given ID.<br> <br> Note: The state of a Template Subscription can only be set to OFFLINE or PUBLISHED.<br> <br> Note: The limits of a Template subscription (CPU, RAM, etc.) cannot exceed the value included in the Registration.  # 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_template_subscription(id, subscription_id, input_template_subscription, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int subscription_id: ID of template subscription (required)
        :param InputTemplateSubscription input_template_subscription: The modified template subscription data (required)
        :param bool offline: The desired template subscription state
        :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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.update_template_subscription_with_http_info(id, subscription_id, input_template_subscription, **kwargs)  # noqa: E501

    def update_template_subscription_with_http_info(self, id, subscription_id, input_template_subscription, **kwargs):  # noqa: E501
        """Update Template Subscription  # noqa: E501

        Updates the Template Subscription for a single Virtualization Realm by the given ID.<br> <br> Note: The state of a Template Subscription can only be set to OFFLINE or PUBLISHED.<br> <br> Note: The limits of a Template subscription (CPU, RAM, etc.) cannot exceed the value included in the Registration.  # 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_template_subscription_with_http_info(id, subscription_id, input_template_subscription, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int subscription_id: ID of template subscription (required)
        :param InputTemplateSubscription input_template_subscription: The modified template subscription data (required)
        :param bool offline: The desired template subscription state
        :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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id', 'subscription_id', 'input_template_subscription', 'offline']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_template_subscription" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `update_template_subscription`")  # noqa: E501
        # verify the required parameter 'subscription_id' is set
        if self.api_client.client_side_validation and ('subscription_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['subscription_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `subscription_id` when calling `update_template_subscription`")  # noqa: E501
        # verify the required parameter 'input_template_subscription' is set
        if self.api_client.client_side_validation and ('input_template_subscription' not in local_var_params or  # noqa: E501
                                                        local_var_params['input_template_subscription'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `input_template_subscription` when calling `update_template_subscription`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501
        if 'subscription_id' in local_var_params:
            path_params['subscription_id'] = local_var_params['subscription_id']  # noqa: E501

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

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/subscriptions/{subscription_id}', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='bool',  # 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_virt_realm_remote_access_config(self, id, remote_access_config, **kwargs):  # noqa: E501
        """Update Remote Access  # noqa: E501

        Updates the Remote Access configuration for a single Virtualization Realm by the given ID.<br> <br> Note: remoteAccessIpAddress cannot be updated if the Virtualization Realm's Remote Access is currently enabled.  # 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_virt_realm_remote_access_config(id, remote_access_config, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param RemoteAccessConfig remote_access_config: The updated remote access configuration (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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.update_virt_realm_remote_access_config_with_http_info(id, remote_access_config, **kwargs)  # noqa: E501

    def update_virt_realm_remote_access_config_with_http_info(self, id, remote_access_config, **kwargs):  # noqa: E501
        """Update Remote Access  # noqa: E501

        Updates the Remote Access configuration for a single Virtualization Realm by the given ID.<br> <br> Note: remoteAccessIpAddress cannot be updated if the Virtualization Realm's Remote Access is currently enabled.  # 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_virt_realm_remote_access_config_with_http_info(id, remote_access_config, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param RemoteAccessConfig remote_access_config: The updated remote access configuration (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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id', 'remote_access_config']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_virt_realm_remote_access_config" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `update_virt_realm_remote_access_config`")  # noqa: E501
        # verify the required parameter 'remote_access_config' is set
        if self.api_client.client_side_validation and ('remote_access_config' not in local_var_params or  # noqa: E501
                                                        local_var_params['remote_access_config'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `remote_access_config` when calling `update_virt_realm_remote_access_config`")  # noqa: E501

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/remoteaccess', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='bool',  # 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_virtualization_realm(self, id, **kwargs):  # noqa: E501
        """Update Virtualization Realm  # noqa: E501

        Updates the content of a single Virtualization Realm with the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.update_virtualization_realm(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param InputVRAdminVirtualizationRealm input_vr_admin_virtualization_realm: The updated Virtualization Realm data
        :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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.update_virtualization_realm_with_http_info(id, **kwargs)  # noqa: E501

    def update_virtualization_realm_with_http_info(self, id, **kwargs):  # noqa: E501
        """Update Virtualization Realm  # noqa: E501

        Updates the content of a single Virtualization Realm with the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.update_virtualization_realm_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param InputVRAdminVirtualizationRealm input_vr_admin_virtualization_realm: The updated Virtualization Realm data
        :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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id', 'input_vr_admin_virtualization_realm']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_virtualization_realm" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `update_virtualization_realm`")  # noqa: E501

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='bool',  # 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_virtualization_realm_reachability(self, id, **kwargs):  # noqa: E501
        """update_virtualization_realm_reachability  # 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_virtualization_realm_reachability(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.update_virtualization_realm_reachability_with_http_info(id, **kwargs)  # noqa: E501

    def update_virtualization_realm_reachability_with_http_info(self, id, **kwargs):  # noqa: E501
        """update_virtualization_realm_reachability  # 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_virtualization_realm_reachability_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_virtualization_realm_reachability" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `update_virtualization_realm_reachability`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['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(
            ['application/json', 'application/xml'])  # noqa: E501

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/updatereachability', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='bool',  # 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)

84d3599a88ad0646b3b3837e1770f2bec53407ef
<mask token>


class VirtualizationRealmsApi(object):
    <mask token>

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

    def add_network(self, id, abstract_add_network_cloud_space_request, **
        kwargs):
        """Allocate Network  # noqa: E501

        Adds a Network to the specified Virtualization Realm.<br> <br> Since this call results in the construction of a new, back-end Network it has financial implications and should not be used if the user is not prepared to incur the expense of construction and existence of the newly created Network.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.add_network(id, abstract_add_network_cloud_space_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param AbstractAddNetworkCloudSpaceRequest abstract_add_network_cloud_space_request: The network allocation information (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: MinimalVirtualizationRealm
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.add_network_with_http_info(id,
            abstract_add_network_cloud_space_request, **kwargs)

    def add_network_with_http_info(self, id,
        abstract_add_network_cloud_space_request, **kwargs):
        """Allocate Network  # noqa: E501

        Adds a Network to the specified Virtualization Realm.<br> <br> Since this call results in the construction of a new, back-end Network it has financial implications and should not be used if the user is not prepared to incur the expense of construction and existence of the newly created Network.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.add_network_with_http_info(id, abstract_add_network_cloud_space_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param AbstractAddNetworkCloudSpaceRequest abstract_add_network_cloud_space_request: The network allocation information (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(MinimalVirtualizationRealm, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'abstract_add_network_cloud_space_request']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 add_network"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `add_network`'
                )
        if self.api_client.client_side_validation and (
            'abstract_add_network_cloud_space_request' not in
            local_var_params or local_var_params[
            'abstract_add_network_cloud_space_request'] is None):
            raise ApiValueError(
                'Missing the required parameter `abstract_add_network_cloud_space_request` when calling `add_network`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        if 'abstract_add_network_cloud_space_request' in local_var_params:
            body_params = local_var_params[
                'abstract_add_network_cloud_space_request']
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        header_params['Content-Type'
            ] = self.api_client.select_header_content_type([
            'application/json', 'application/xml'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/networks', 'POST', path_params,
            query_params, header_params, body=body_params, post_params=
            form_params, files=local_var_files, response_type=
            'MinimalVirtualizationRealm', auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def add_project(self, id, project_id, **kwargs):
        """Assign Project  # noqa: E501

        Provides members of the Project with access to the specified Virtualization Realm  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.add_project(id, project_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param str project_id: ID of project to assign (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: int
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.add_project_with_http_info(id, project_id, **kwargs)
    <mask token>

    def create_template_subsciption(self, id, registration_id, **kwargs):
        """Create Template Subscription  # noqa: E501

        Creates a Template Subscription in the specified Virtualization Realm.  # 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_template_subsciption(id, registration_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (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: FullTemplateSubscription
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.create_template_subsciption_with_http_info(id,
            registration_id, **kwargs)

    def create_template_subsciption_with_http_info(self, id,
        registration_id, **kwargs):
        """Create Template Subscription  # noqa: E501

        Creates a Template Subscription in the specified Virtualization Realm.  # 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_template_subsciption_with_http_info(id, registration_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (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(FullTemplateSubscription, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'registration_id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_template_subsciption"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `create_template_subsciption`'
                )
        if self.api_client.client_side_validation and ('registration_id' not in
            local_var_params or local_var_params['registration_id'] is None):
            raise ApiValueError(
                'Missing the required parameter `registration_id` when calling `create_template_subsciption`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        if 'registration_id' in local_var_params and local_var_params[
            'registration_id'] is not None:
            query_params.append(('registration_id', local_var_params[
                'registration_id']))
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/subscriptions',
            'POST', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='FullTemplateSubscription', auth_settings=
            auth_settings, async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def delete_network(self, id, network_id, **kwargs):
        """Delete Network  # noqa: E501

        Removes an existing Network from the specified Virtualization Realm.  # 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_network(id, network_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param int network_id: ID of network (required)
        :param bool deallocate: Attempt to delete all back-end resources
        :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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.delete_network_with_http_info(id, network_id, **kwargs)
    <mask token>

    def delete_template_subscription(self, id, subscription_id, **kwargs):
        """Delete Template Subscription  # noqa: E501

        Removes an existing Template Subscription from the specified Virtualization Realm.  # 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_template_subscription(id, subscription_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int subscription_id: ID of template subscription (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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.delete_template_subscription_with_http_info(id,
            subscription_id, **kwargs)

    def delete_template_subscription_with_http_info(self, id,
        subscription_id, **kwargs):
        """Delete Template Subscription  # noqa: E501

        Removes an existing Template Subscription from the specified Virtualization Realm.  # 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_template_subscription_with_http_info(id, subscription_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int subscription_id: ID of template subscription (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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'subscription_id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_template_subscription"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `delete_template_subscription`'
                )
        if self.api_client.client_side_validation and ('subscription_id' not in
            local_var_params or local_var_params['subscription_id'] is None):
            raise ApiValueError(
                'Missing the required parameter `subscription_id` when calling `delete_template_subscription`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        if 'subscription_id' in local_var_params:
            path_params['subscription_id'] = local_var_params['subscription_id'
                ]
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/subscriptions/{subscription_id}'
            , 'DELETE', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='bool', auth_settings=auth_settings, async_req=
            local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def disable_virt_realm_remote_access(self, id, **kwargs):
        """Disable Remote Access  # noqa: E501

        Disables Remote Access for a single Virtualization Realm by the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.disable_virt_realm_remote_access(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.disable_virt_realm_remote_access_with_http_info(id, **
            kwargs)
    <mask token>

    def enable_maintence_mode1(self, id, **kwargs):
        """Update Maintenance Mode  # noqa: E501

        Updates the maintenance status for a single Virtualization Realm by the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.enable_maintence_mode1(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param bool enable: Enable or disable maintenance mode
        :param MaintenanceModeRequest maintenance_mode_request: The maintenance mode request, when enabling maintenance mode
        :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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.enable_maintence_mode1_with_http_info(id, **kwargs)
    <mask token>

    def enable_virt_realm_remote_access(self, id, **kwargs):
        """Enable Remote Access  # noqa: E501

        Enables Remote Access for a single Virtualization Realm by the given ID.<br> <br> To do so, Remote Access must be configured for the Virtualization Realm.<br> <br> If no instanceType is provided, the Instance Type will first attempt to use the value from the Virtualization Realm's Remote Access config.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.enable_virt_realm_remote_access(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param str instance_type: Remote access server instance type
        :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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.enable_virt_realm_remote_access_with_http_info(id, **kwargs
            )

    def enable_virt_realm_remote_access_with_http_info(self, id, **kwargs):
        """Enable Remote Access  # noqa: E501

        Enables Remote Access for a single Virtualization Realm by the given ID.<br> <br> To do so, Remote Access must be configured for the Virtualization Realm.<br> <br> If no instanceType is provided, the Instance Type will first attempt to use the value from the Virtualization Realm's Remote Access config.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.enable_virt_realm_remote_access_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param str instance_type: Remote access server instance type
        :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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'instance_type']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 enable_virt_realm_remote_access"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `enable_virt_realm_remote_access`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        if 'instance_type' in local_var_params and local_var_params[
            'instance_type'] is not None:
            query_params.append(('instanceType', local_var_params[
                'instance_type']))
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/remoteaccess', 'POST',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'bool', auth_settings=auth_settings, async_req=local_var_params
            .get('async_req'), _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)
    <mask token>

    def get_deployment_runs_in_virtualization_realm_with_http_info(self, id,
        search_type, **kwargs):
        """List Deployment Runs  # noqa: E501

        Returns a collection of the Deployment Runs launched into the specified Virtualization Realm.  # 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_deployment_runs_in_virtualization_realm_with_http_info(id, search_type, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param str search_type: Deployment run status type (required)
        :param int maxresults: Maximum number of results to return
        :param int page: Requested page number
        :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[MinimalDeploymentRun], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'search_type', 'maxresults', 'page']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_deployment_runs_in_virtualization_realm"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `get_deployment_runs_in_virtualization_realm`'
                )
        if self.api_client.client_side_validation and ('search_type' not in
            local_var_params or local_var_params['search_type'] is None):
            raise ApiValueError(
                'Missing the required parameter `search_type` when calling `get_deployment_runs_in_virtualization_realm`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        if 'search_type' in local_var_params and local_var_params['search_type'
            ] is not None:
            query_params.append(('search_type', local_var_params[
                'search_type']))
        if 'maxresults' in local_var_params and local_var_params['maxresults'
            ] is not None:
            query_params.append(('maxresults', local_var_params['maxresults']))
        if 'page' in local_var_params and local_var_params['page'] is not None:
            query_params.append(('page', local_var_params['page']))
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/deploymentruns', 'GET',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'list[MinimalDeploymentRun]', auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def get_host_configuration_metrics1(self, id, start, end, **kwargs):
        """Retrieve Metrics  # noqa: E501

        Returns metric data for Deployment Runs launched into the specified Virtualization Realm.  # 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_host_configuration_metrics1(id, start, end, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param int start: Interval start time, specified in seconds since epoch (required)
        :param int end: Interval end time, specified in seconds since epoch (required)
        :param int interval: Number of intervals
        :param str interval_unit: Interval unit
        :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_host_configuration_metrics1_with_http_info(id,
            start, end, **kwargs)
    <mask token>

    def get_network(self, id, network_id, **kwargs):
        """Retrieve Network  # noqa: E501

        Returns a single Network in the specified Virtualization Realm.  # 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_network(id, network_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param int network_id: ID of network (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: Network
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_network_with_http_info(id, network_id, **kwargs)

    def get_network_with_http_info(self, id, network_id, **kwargs):
        """Retrieve Network  # noqa: E501

        Returns a single Network in the specified Virtualization Realm.  # 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_network_with_http_info(id, network_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param int network_id: ID of network (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(Network, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'network_id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_network"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `get_network`'
                )
        if self.api_client.client_side_validation and ('network_id' not in
            local_var_params or local_var_params['network_id'] is None):
            raise ApiValueError(
                'Missing the required parameter `network_id` when calling `get_network`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        if 'network_id' in local_var_params:
            path_params['networkId'] = local_var_params['network_id']
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/networks/{networkId}', 'GET',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'Network', auth_settings=auth_settings, async_req=
            local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)
    <mask token>

    def get_networks_with_http_info(self, id, **kwargs):
        """List Networks  # noqa: E501

        Returns a collection of the Networks in the specified Virtualization Realm.  # 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_networks_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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[MinimalNetwork], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_networks"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `get_networks`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/networks', 'GET', path_params,
            query_params, header_params, body=body_params, post_params=
            form_params, files=local_var_files, response_type=
            'list[MinimalNetwork]', auth_settings=auth_settings, async_req=
            local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)
    <mask token>

    def get_template_subscription_with_http_info(self, id, subscription_id,
        **kwargs):
        """Retrieve Template Subscription  # noqa: E501

        Returns a single Template Subscription in the specified Virtualization Realm.  # 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_template_subscription_with_http_info(id, subscription_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int subscription_id: ID of template subscription (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(FullTemplateSubscription, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'subscription_id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_template_subscription"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `get_template_subscription`'
                )
        if self.api_client.client_side_validation and ('subscription_id' not in
            local_var_params or local_var_params['subscription_id'] is None):
            raise ApiValueError(
                'Missing the required parameter `subscription_id` when calling `get_template_subscription`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        if 'subscription_id' in local_var_params:
            path_params['subscription_id'] = local_var_params['subscription_id'
                ]
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/subscriptions/{subscription_id}'
            , 'GET', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='FullTemplateSubscription', auth_settings=
            auth_settings, async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def get_templates_in_virtualization_realm(self, id, **kwargs):
        """List Templates  # noqa: E501

        Returns a collection of the Templates in the specified Virtualization Realm.  # 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_templates_in_virtualization_realm(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param bool include_registrations: Include templates registered to the virtualization realm
        :param bool include_subscriptions: Include templates subscribed to by the virtualization realm
        :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[MinimalCons3rtTemplateData]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_templates_in_virtualization_realm_with_http_info(id,
            **kwargs)

    def get_templates_in_virtualization_realm_with_http_info(self, id, **kwargs
        ):
        """List Templates  # noqa: E501

        Returns a collection of the Templates in the specified Virtualization Realm.  # 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_templates_in_virtualization_realm_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param bool include_registrations: Include templates registered to the virtualization realm
        :param bool include_subscriptions: Include templates subscribed to by the virtualization realm
        :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[MinimalCons3rtTemplateData], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'include_registrations', 'include_subscriptions']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_templates_in_virtualization_realm"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `get_templates_in_virtualization_realm`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        if 'include_registrations' in local_var_params and local_var_params[
            'include_registrations'] is not None:
            query_params.append(('include_registrations', local_var_params[
                'include_registrations']))
        if 'include_subscriptions' in local_var_params and local_var_params[
            'include_subscriptions'] is not None:
            query_params.append(('include_subscriptions', local_var_params[
                'include_subscriptions']))
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates', 'GET', path_params,
            query_params, header_params, body=body_params, post_params=
            form_params, files=local_var_files, response_type=
            'list[MinimalCons3rtTemplateData]', auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def get_unregistered_networks(self, id, **kwargs):
        """List Unregistered Networks  # noqa: E501

        Returns a collection of the unregistered, back-end Networks in the specified Virtualization Realm.  # 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_unregistered_networks(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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[Subnet]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_unregistered_networks_with_http_info(id, **kwargs)

    def get_unregistered_networks_with_http_info(self, id, **kwargs):
        """List Unregistered Networks  # noqa: E501

        Returns a collection of the unregistered, back-end Networks in the specified Virtualization Realm.  # 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_unregistered_networks_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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[Subnet], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_unregistered_networks"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `get_unregistered_networks`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/networks/unregistered', 'GET',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'list[Subnet]', auth_settings=auth_settings, async_req=
            local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)
    <mask token>
    <mask token>

    def get_virtualization_realm(self, id, **kwargs):
        """Retrieve Virtualization Realm  # noqa: E501

        Returns a single Virtualization Realm by the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_virtualization_realm(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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: FullVirtualizationRealm
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_virtualization_realm_with_http_info(id, **kwargs)

    def get_virtualization_realm_with_http_info(self, id, **kwargs):
        """Retrieve Virtualization Realm  # noqa: E501

        Returns a single Virtualization Realm by the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_virtualization_realm_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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(FullVirtualizationRealm, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_virtualization_realm"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `get_virtualization_realm`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api('/api/virtualizationrealms/{id}',
            'GET', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='FullVirtualizationRealm', auth_settings=
            auth_settings, async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def get_virtualization_realm_resources(self, id, **kwargs):
        """Retrieve Virtualization Realm Resources  # noqa: E501

        Returns the back-end resources for a single Virtualization Realm by the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_virtualization_realm_resources(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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: AbstractCloudResources
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_virtualization_realm_resources_with_http_info(id,
            **kwargs)

    def get_virtualization_realm_resources_with_http_info(self, id, **kwargs):
        """Retrieve Virtualization Realm Resources  # noqa: E501

        Returns the back-end resources for a single Virtualization Realm by the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_virtualization_realm_resources_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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(AbstractCloudResources, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_virtualization_realm_resources"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `get_virtualization_realm_resources`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/resources', 'GET', path_params,
            query_params, header_params, body=body_params, post_params=
            form_params, files=local_var_files, response_type=
            'AbstractCloudResources', auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def get_virtualization_realms(self, **kwargs):
        """List Virtualization Realms  # noqa: E501

        Returns a collection of the Virtualization Realms that the user manages.  # 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_virtualization_realms(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int maxresults: Maximum number of results to return
        :param int page: Requested page number
        :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[MinimalVirtualizationRealm]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_virtualization_realms_with_http_info(**kwargs)

    def get_virtualization_realms_with_http_info(self, **kwargs):
        """List Virtualization Realms  # noqa: E501

        Returns a collection of the Virtualization Realms that the user manages.  # 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_virtualization_realms_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int maxresults: Maximum number of results to return
        :param int page: Requested page number
        :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[MinimalVirtualizationRealm], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['maxresults', 'page']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_virtualization_realms"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        collection_formats = {}
        path_params = {}
        query_params = []
        if 'maxresults' in local_var_params and local_var_params['maxresults'
            ] is not None:
            query_params.append(('maxresults', local_var_params['maxresults']))
        if 'page' in local_var_params and local_var_params['page'] is not None:
            query_params.append(('page', local_var_params['page']))
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api('/api/virtualizationrealms', 'GET',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'list[MinimalVirtualizationRealm]', auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)
    <mask token>

    def invalidate_template_cache_in_virtualization_realm_with_http_info(self,
        id, **kwargs):
        """Refresh Template Cache  # noqa: E501

        Forces the back-end Template data to be re-read in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.invalidate_template_cache_in_virtualization_realm_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 invalidate_template_cache_in_virtualization_realm"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `invalidate_template_cache_in_virtualization_realm`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/registrations', 'PUT',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'bool', auth_settings=auth_settings, async_req=local_var_params
            .get('async_req'), _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def list_pending_template_subscriptions(self, id, **kwargs):
        """List Pending Subscriptions  # noqa: E501

        Returns a collection of the pending Template Subscriptions in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_pending_template_subscriptions(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (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[FullTemplateRegistrationForSubscription]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.list_pending_template_subscriptions_with_http_info(id,
            **kwargs)

    def list_pending_template_subscriptions_with_http_info(self, id, **kwargs):
        """List Pending Subscriptions  # noqa: E501

        Returns a collection of the pending Template Subscriptions in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_pending_template_subscriptions_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (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[FullTemplateRegistrationForSubscription], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 list_pending_template_subscriptions"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `list_pending_template_subscriptions`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/subscriptions/pending',
            'GET', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='list[FullTemplateRegistrationForSubscription]',
            auth_settings=auth_settings, async_req=local_var_params.get(
            'async_req'), _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def list_projects(self, id, **kwargs):
        """List Projects  # noqa: E501

        Returns a collection of the Projects allowed to access to the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_projects(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param int maxresults: Maximum number of results to return
        :param int page: Requested page number
        :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[MinimalProject]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.list_projects_with_http_info(id, **kwargs)

    def list_projects_with_http_info(self, id, **kwargs):
        """List Projects  # noqa: E501

        Returns a collection of the Projects allowed to access to the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_projects_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param int maxresults: Maximum number of results to return
        :param int page: Requested page number
        :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[MinimalProject], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'maxresults', 'page']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 list_projects"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `list_projects`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        if 'maxresults' in local_var_params and local_var_params['maxresults'
            ] is not None:
            query_params.append(('maxresults', local_var_params['maxresults']))
        if 'page' in local_var_params and local_var_params['page'] is not None:
            query_params.append(('page', local_var_params['page']))
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/projects', 'GET', path_params,
            query_params, header_params, body=body_params, post_params=
            form_params, files=local_var_files, response_type=
            'list[MinimalProject]', auth_settings=auth_settings, async_req=
            local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)
    <mask token>
    <mask token>

    def list_template_subscriptions(self, id, **kwargs):
        """List Template Subscriptions  # noqa: E501

        Returns a collection of the Template Subscriptions in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_template_subscriptions(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (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[MinimalTemplateSubscription]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.list_template_subscriptions_with_http_info(id, **kwargs)
    <mask token>
    <mask token>

    def list_unregistered_templates_with_http_info(self, id, **kwargs):
        """List Unregistered Templates  # noqa: E501

        Returns a collection of the unregistered, back-end Templates in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_unregistered_templates_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (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[Cons3rtTemplateTagData], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 list_unregistered_templates"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `list_unregistered_templates`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/registrations/pending',
            'GET', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='list[Cons3rtTemplateTagData]', auth_settings=
            auth_settings, async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def register_network(self, id, network_identifier, **kwargs):
        """Register Network  # noqa: E501

        Adds an existing, back-end Network the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.register_network(id, network_identifier, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param str network_identifier: Back-end network identifier (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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.register_network_with_http_info(id, network_identifier,
            **kwargs)

    def register_network_with_http_info(self, id, network_identifier, **kwargs
        ):
        """Register Network  # noqa: E501

        Adds an existing, back-end Network the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.register_network_with_http_info(id, network_identifier, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param str network_identifier: Back-end network identifier (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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'network_identifier']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 register_network"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `register_network`'
                )
        if self.api_client.client_side_validation and ('network_identifier'
             not in local_var_params or local_var_params[
            'network_identifier'] is None):
            raise ApiValueError(
                'Missing the required parameter `network_identifier` when calling `register_network`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        if 'network_identifier' in local_var_params:
            path_params['networkIdentifier'] = local_var_params[
                'network_identifier']
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/networks/{networkIdentifier}',
            'PUT', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='bool', auth_settings=auth_settings, async_req=
            local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def register_template(self, id, **kwargs):
        """Register Template  # noqa: E501

        Adds an existing back-end Template to the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.register_template(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param InputRegisterTemplateObject input_register_template_object: The template registration data
        :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: FullTemplateRegistration
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.register_template_with_http_info(id, **kwargs)
    <mask token>
    <mask token>

    def remove_project_with_http_info(self, id, project_id, **kwargs):
        """Unassign Project  # noqa: E501

        Revokes Project member access to the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.remove_project_with_http_info(id, project_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param str project_id: ID of project to unassign (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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'project_id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 remove_project"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `remove_project`'
                )
        if self.api_client.client_side_validation and ('project_id' not in
            local_var_params or local_var_params['project_id'] is None):
            raise ApiValueError(
                'Missing the required parameter `project_id` when calling `remove_project`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        if 'project_id' in local_var_params and local_var_params['project_id'
            ] is not None:
            query_params.append(('projectId', local_var_params['project_id']))
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/projects', 'DELETE',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'bool', auth_settings=auth_settings, async_req=local_var_params
            .get('async_req'), _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)
    <mask token>

    def retrieve_template_registration_with_http_info(self, id,
        registration_id, **kwargs):
        """Retrieve Template Registration  # noqa: E501

        Returns a single Template Registration in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_template_registration_with_http_info(id, registration_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (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(FullTemplateRegistration, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'registration_id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 retrieve_template_registration"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `retrieve_template_registration`'
                )
        if self.api_client.client_side_validation and ('registration_id' not in
            local_var_params or local_var_params['registration_id'] is None):
            raise ApiValueError(
                'Missing the required parameter `registration_id` when calling `retrieve_template_registration`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        if 'registration_id' in local_var_params:
            path_params['registration_id'] = local_var_params['registration_id'
                ]
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/registrations/{registration_id}'
            , 'GET', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='FullTemplateRegistration', auth_settings=
            auth_settings, async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def set_virtualization_realm_active(self, id, activate, **kwargs):
        """Update State  # noqa: E501

        Updates the active State for a single Virtualization Realm by the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.set_virtualization_realm_active(id, activate, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param bool activate: Activate or deactivate virtualization realm (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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.set_virtualization_realm_active_with_http_info(id,
            activate, **kwargs)
    <mask token>
    <mask token>
    <mask token>

    def unregister_template(self, id, registration_id,
        input_unregister_template_object, **kwargs):
        """Delete Template Registration  # noqa: E501

        Removes an existing Template Registration from the specified Virtualization Realm.<br> <br> Note: Unregistering a Template will remove all subscriptions to the Template from other Virtualization Realms.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.unregister_template(id, registration_id, input_unregister_template_object, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (required)
        :param InputUnregisterTemplateObject input_unregister_template_object: The deletion settings (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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.unregister_template_with_http_info(id, registration_id,
            input_unregister_template_object, **kwargs)

    def unregister_template_with_http_info(self, id, registration_id,
        input_unregister_template_object, **kwargs):
        """Delete Template Registration  # noqa: E501

        Removes an existing Template Registration from the specified Virtualization Realm.<br> <br> Note: Unregistering a Template will remove all subscriptions to the Template from other Virtualization Realms.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.unregister_template_with_http_info(id, registration_id, input_unregister_template_object, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (required)
        :param InputUnregisterTemplateObject input_unregister_template_object: The deletion settings (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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'registration_id',
            'input_unregister_template_object']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 unregister_template"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `unregister_template`'
                )
        if self.api_client.client_side_validation and ('registration_id' not in
            local_var_params or local_var_params['registration_id'] is None):
            raise ApiValueError(
                'Missing the required parameter `registration_id` when calling `unregister_template`'
                )
        if self.api_client.client_side_validation and (
            'input_unregister_template_object' not in local_var_params or 
            local_var_params['input_unregister_template_object'] is None):
            raise ApiValueError(
                'Missing the required parameter `input_unregister_template_object` when calling `unregister_template`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        if 'registration_id' in local_var_params:
            path_params['registration_id'] = local_var_params['registration_id'
                ]
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        if 'input_unregister_template_object' in local_var_params:
            body_params = local_var_params['input_unregister_template_object']
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        header_params['Content-Type'
            ] = self.api_client.select_header_content_type([
            'application/json', 'application/xml'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/registrations/{registration_id}'
            , 'DELETE', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='bool', auth_settings=auth_settings, async_req=
            local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def unshare_template_registration(self, id, registration_id,
        target_realm_id, **kwargs):
        """Unshare Template  # noqa: E501

        Revokes access to a Template Registration in the specified Virtualization Realm by the provided external Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.unshare_template_registration(id, registration_id, target_realm_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (required)
        :param int target_realm_id: ID of external virtualization realm to revoke template registration access for (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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.unshare_template_registration_with_http_info(id,
            registration_id, target_realm_id, **kwargs)

    def unshare_template_registration_with_http_info(self, id,
        registration_id, target_realm_id, **kwargs):
        """Unshare Template  # noqa: E501

        Revokes access to a Template Registration in the specified Virtualization Realm by the provided external Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.unshare_template_registration_with_http_info(id, registration_id, target_realm_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (required)
        :param int target_realm_id: ID of external virtualization realm to revoke template registration access for (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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'registration_id', 'target_realm_id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 unshare_template_registration"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `unshare_template_registration`'
                )
        if self.api_client.client_side_validation and ('registration_id' not in
            local_var_params or local_var_params['registration_id'] is None):
            raise ApiValueError(
                'Missing the required parameter `registration_id` when calling `unshare_template_registration`'
                )
        if self.api_client.client_side_validation and ('target_realm_id' not in
            local_var_params or local_var_params['target_realm_id'] is None):
            raise ApiValueError(
                'Missing the required parameter `target_realm_id` when calling `unshare_template_registration`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        if 'registration_id' in local_var_params:
            path_params['registration_id'] = local_var_params['registration_id'
                ]
        query_params = []
        if 'target_realm_id' in local_var_params and local_var_params[
            'target_realm_id'] is not None:
            query_params.append(('target_realm_id', local_var_params[
                'target_realm_id']))
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/registrations/{registration_id}/share'
            , 'DELETE', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='bool', auth_settings=auth_settings, async_req=
            local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)
    <mask token>

    def update_template_registration_with_http_info(self, id,
        registration_id, input_cons3rt_template_data, **kwargs):
        """Update Template Registration  # noqa: E501

        Updates the Template Registration for a single Virtualization Realm by the given ID.<br> <br> Note: The state of a Template Registration can only be set to OFFLINE or PUBLISHED.<br> <br> Note: All fields in Template data are honored on update, therefore any configuration that is desired in the updated Registration should be provided.  # 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_template_registration_with_http_info(id, registration_id, input_cons3rt_template_data, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (required)
        :param InputCons3rtTemplateData input_cons3rt_template_data: The modified template registration data (required)
        :param bool offline: The desired template registration state
        :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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'registration_id',
            'input_cons3rt_template_data', 'offline']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_template_registration"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `update_template_registration`'
                )
        if self.api_client.client_side_validation and ('registration_id' not in
            local_var_params or local_var_params['registration_id'] is None):
            raise ApiValueError(
                'Missing the required parameter `registration_id` when calling `update_template_registration`'
                )
        if self.api_client.client_side_validation and (
            'input_cons3rt_template_data' not in local_var_params or 
            local_var_params['input_cons3rt_template_data'] is None):
            raise ApiValueError(
                'Missing the required parameter `input_cons3rt_template_data` when calling `update_template_registration`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        if 'registration_id' in local_var_params:
            path_params['registration_id'] = local_var_params['registration_id'
                ]
        query_params = []
        if 'offline' in local_var_params and local_var_params['offline'
            ] is not None:
            query_params.append(('offline', local_var_params['offline']))
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        if 'input_cons3rt_template_data' in local_var_params:
            body_params = local_var_params['input_cons3rt_template_data']
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        header_params['Content-Type'
            ] = self.api_client.select_header_content_type([
            'application/json', 'application/xml'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/registrations/{registration_id}'
            , 'PUT', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='bool', auth_settings=auth_settings, async_req=
            local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def update_template_subscription(self, id, subscription_id,
        input_template_subscription, **kwargs):
        """Update Template Subscription  # noqa: E501

        Updates the Template Subscription for a single Virtualization Realm by the given ID.<br> <br> Note: The state of a Template Subscription can only be set to OFFLINE or PUBLISHED.<br> <br> Note: The limits of a Template subscription (CPU, RAM, etc.) cannot exceed the value included in the Registration.  # 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_template_subscription(id, subscription_id, input_template_subscription, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int subscription_id: ID of template subscription (required)
        :param InputTemplateSubscription input_template_subscription: The modified template subscription data (required)
        :param bool offline: The desired template subscription state
        :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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.update_template_subscription_with_http_info(id,
            subscription_id, input_template_subscription, **kwargs)
    <mask token>

    def update_virt_realm_remote_access_config(self, id,
        remote_access_config, **kwargs):
        """Update Remote Access  # noqa: E501

        Updates the Remote Access configuration for a single Virtualization Realm by the given ID.<br> <br> Note: remoteAccessIpAddress cannot be updated if the Virtualization Realm's Remote Access is currently enabled.  # 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_virt_realm_remote_access_config(id, remote_access_config, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param RemoteAccessConfig remote_access_config: The updated remote access configuration (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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.update_virt_realm_remote_access_config_with_http_info(id,
            remote_access_config, **kwargs)

    def update_virt_realm_remote_access_config_with_http_info(self, id,
        remote_access_config, **kwargs):
        """Update Remote Access  # noqa: E501

        Updates the Remote Access configuration for a single Virtualization Realm by the given ID.<br> <br> Note: remoteAccessIpAddress cannot be updated if the Virtualization Realm's Remote Access is currently enabled.  # 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_virt_realm_remote_access_config_with_http_info(id, remote_access_config, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param RemoteAccessConfig remote_access_config: The updated remote access configuration (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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'remote_access_config']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_virt_realm_remote_access_config"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `update_virt_realm_remote_access_config`'
                )
        if self.api_client.client_side_validation and (
            'remote_access_config' not in local_var_params or 
            local_var_params['remote_access_config'] is None):
            raise ApiValueError(
                'Missing the required parameter `remote_access_config` when calling `update_virt_realm_remote_access_config`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        if 'remote_access_config' in local_var_params:
            body_params = local_var_params['remote_access_config']
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        header_params['Content-Type'
            ] = self.api_client.select_header_content_type([
            'application/json', 'application/xml'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/remoteaccess', 'PUT',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'bool', auth_settings=auth_settings, async_req=local_var_params
            .get('async_req'), _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)
    <mask token>

    def update_virtualization_realm_with_http_info(self, id, **kwargs):
        """Update Virtualization Realm  # noqa: E501

        Updates the content of a single Virtualization Realm with the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.update_virtualization_realm_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param InputVRAdminVirtualizationRealm input_vr_admin_virtualization_realm: The updated Virtualization Realm data
        :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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'input_vr_admin_virtualization_realm']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_virtualization_realm"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `update_virtualization_realm`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        if 'input_vr_admin_virtualization_realm' in local_var_params:
            body_params = local_var_params[
                'input_vr_admin_virtualization_realm']
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        header_params['Content-Type'
            ] = self.api_client.select_header_content_type([
            'application/json', 'application/xml'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api('/api/virtualizationrealms/{id}',
            'PUT', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='bool', auth_settings=auth_settings, async_req=
            local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def update_virtualization_realm_reachability(self, id, **kwargs):
        """update_virtualization_realm_reachability  # 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_virtualization_realm_reachability(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.update_virtualization_realm_reachability_with_http_info(id,
            **kwargs)

    def update_virtualization_realm_reachability_with_http_info(self, id,
        **kwargs):
        """update_virtualization_realm_reachability  # 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_virtualization_realm_reachability_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_virtualization_realm_reachability"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `update_virtualization_realm_reachability`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json', 'application/xml'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/updatereachability', 'PUT',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'bool', auth_settings=auth_settings, async_req=local_var_params
            .get('async_req'), _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

<mask token>


class VirtualizationRealmsApi(object):
    <mask token>

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

    def add_network(self, id, abstract_add_network_cloud_space_request, **
        kwargs):
        """Allocate Network  # noqa: E501

        Adds a Network to the specified Virtualization Realm.<br> <br> Since this call results in the construction of a new, back-end Network it has financial implications and should not be used if the user is not prepared to incur the expense of construction and existence of the newly created Network.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.add_network(id, abstract_add_network_cloud_space_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param AbstractAddNetworkCloudSpaceRequest abstract_add_network_cloud_space_request: The network allocation information (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: MinimalVirtualizationRealm
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.add_network_with_http_info(id,
            abstract_add_network_cloud_space_request, **kwargs)

    def add_network_with_http_info(self, id,
        abstract_add_network_cloud_space_request, **kwargs):
        """Allocate Network  # noqa: E501

        Adds a Network to the specified Virtualization Realm.<br> <br> Since this call results in the construction of a new, back-end Network it has financial implications and should not be used if the user is not prepared to incur the expense of construction and existence of the newly created Network.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.add_network_with_http_info(id, abstract_add_network_cloud_space_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param AbstractAddNetworkCloudSpaceRequest abstract_add_network_cloud_space_request: The network allocation information (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(MinimalVirtualizationRealm, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'abstract_add_network_cloud_space_request']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 add_network"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `add_network`'
                )
        if self.api_client.client_side_validation and (
            'abstract_add_network_cloud_space_request' not in
            local_var_params or local_var_params[
            'abstract_add_network_cloud_space_request'] is None):
            raise ApiValueError(
                'Missing the required parameter `abstract_add_network_cloud_space_request` when calling `add_network`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        if 'abstract_add_network_cloud_space_request' in local_var_params:
            body_params = local_var_params[
                'abstract_add_network_cloud_space_request']
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        header_params['Content-Type'
            ] = self.api_client.select_header_content_type([
            'application/json', 'application/xml'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/networks', 'POST', path_params,
            query_params, header_params, body=body_params, post_params=
            form_params, files=local_var_files, response_type=
            'MinimalVirtualizationRealm', auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def add_project(self, id, project_id, **kwargs):
        """Assign Project  # noqa: E501

        Provides members of the Project with access to the specified Virtualization Realm  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.add_project(id, project_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param str project_id: ID of project to assign (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: int
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.add_project_with_http_info(id, project_id, **kwargs)
    <mask token>

    def create_template_subsciption(self, id, registration_id, **kwargs):
        """Create Template Subscription  # noqa: E501

        Creates a Template Subscription in the specified Virtualization Realm.  # 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_template_subsciption(id, registration_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (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: FullTemplateSubscription
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.create_template_subsciption_with_http_info(id,
            registration_id, **kwargs)

    def create_template_subsciption_with_http_info(self, id,
        registration_id, **kwargs):
        """Create Template Subscription  # noqa: E501

        Creates a Template Subscription in the specified Virtualization Realm.  # 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_template_subsciption_with_http_info(id, registration_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (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(FullTemplateSubscription, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'registration_id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_template_subsciption"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `create_template_subsciption`'
                )
        if self.api_client.client_side_validation and ('registration_id' not in
            local_var_params or local_var_params['registration_id'] is None):
            raise ApiValueError(
                'Missing the required parameter `registration_id` when calling `create_template_subsciption`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        if 'registration_id' in local_var_params and local_var_params[
            'registration_id'] is not None:
            query_params.append(('registration_id', local_var_params[
                'registration_id']))
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/subscriptions',
            'POST', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='FullTemplateSubscription', auth_settings=
            auth_settings, async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def delete_network(self, id, network_id, **kwargs):
        """Delete Network  # noqa: E501

        Removes an existing Network from the specified Virtualization Realm.  # 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_network(id, network_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param int network_id: ID of network (required)
        :param bool deallocate: Attempt to delete all back-end resources
        :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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.delete_network_with_http_info(id, network_id, **kwargs)
    <mask token>

    def delete_template_subscription(self, id, subscription_id, **kwargs):
        """Delete Template Subscription  # noqa: E501

        Removes an existing Template Subscription from the specified Virtualization Realm.  # 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_template_subscription(id, subscription_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int subscription_id: ID of template subscription (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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.delete_template_subscription_with_http_info(id,
            subscription_id, **kwargs)

    def delete_template_subscription_with_http_info(self, id,
        subscription_id, **kwargs):
        """Delete Template Subscription  # noqa: E501

        Removes an existing Template Subscription from the specified Virtualization Realm.  # 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_template_subscription_with_http_info(id, subscription_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int subscription_id: ID of template subscription (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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'subscription_id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_template_subscription"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `delete_template_subscription`'
                )
        if self.api_client.client_side_validation and ('subscription_id' not in
            local_var_params or local_var_params['subscription_id'] is None):
            raise ApiValueError(
                'Missing the required parameter `subscription_id` when calling `delete_template_subscription`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        if 'subscription_id' in local_var_params:
            path_params['subscription_id'] = local_var_params['subscription_id'
                ]
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/subscriptions/{subscription_id}'
            , 'DELETE', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='bool', auth_settings=auth_settings, async_req=
            local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def disable_virt_realm_remote_access(self, id, **kwargs):
        """Disable Remote Access  # noqa: E501

        Disables Remote Access for a single Virtualization Realm by the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.disable_virt_realm_remote_access(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.disable_virt_realm_remote_access_with_http_info(id, **
            kwargs)
    <mask token>

    def enable_maintence_mode1(self, id, **kwargs):
        """Update Maintenance Mode  # noqa: E501

        Updates the maintenance status for a single Virtualization Realm by the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.enable_maintence_mode1(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param bool enable: Enable or disable maintenance mode
        :param MaintenanceModeRequest maintenance_mode_request: The maintenance mode request, when enabling maintenance mode
        :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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.enable_maintence_mode1_with_http_info(id, **kwargs)
    <mask token>

    def enable_virt_realm_remote_access(self, id, **kwargs):
        """Enable Remote Access  # noqa: E501

        Enables Remote Access for a single Virtualization Realm by the given ID.<br> <br> To do so, Remote Access must be configured for the Virtualization Realm.<br> <br> If no instanceType is provided, the Instance Type will first attempt to use the value from the Virtualization Realm's Remote Access config.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.enable_virt_realm_remote_access(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param str instance_type: Remote access server instance type
        :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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.enable_virt_realm_remote_access_with_http_info(id, **kwargs
            )

    def enable_virt_realm_remote_access_with_http_info(self, id, **kwargs):
        """Enable Remote Access  # noqa: E501

        Enables Remote Access for a single Virtualization Realm by the given ID.<br> <br> To do so, Remote Access must be configured for the Virtualization Realm.<br> <br> If no instanceType is provided, the Instance Type will first attempt to use the value from the Virtualization Realm's Remote Access config.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.enable_virt_realm_remote_access_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param str instance_type: Remote access server instance type
        :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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'instance_type']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 enable_virt_realm_remote_access"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `enable_virt_realm_remote_access`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        if 'instance_type' in local_var_params and local_var_params[
            'instance_type'] is not None:
            query_params.append(('instanceType', local_var_params[
                'instance_type']))
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/remoteaccess', 'POST',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'bool', auth_settings=auth_settings, async_req=local_var_params
            .get('async_req'), _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def get_deployment_runs_in_virtualization_realm(self, id, search_type,
        **kwargs):
        """List Deployment Runs  # noqa: E501

        Returns a collection of the Deployment Runs launched into the specified Virtualization Realm.  # 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_deployment_runs_in_virtualization_realm(id, search_type, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param str search_type: Deployment run status type (required)
        :param int maxresults: Maximum number of results to return
        :param int page: Requested page number
        :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[MinimalDeploymentRun]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_deployment_runs_in_virtualization_realm_with_http_info(
            id, search_type, **kwargs)

    def get_deployment_runs_in_virtualization_realm_with_http_info(self, id,
        search_type, **kwargs):
        """List Deployment Runs  # noqa: E501

        Returns a collection of the Deployment Runs launched into the specified Virtualization Realm.  # 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_deployment_runs_in_virtualization_realm_with_http_info(id, search_type, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param str search_type: Deployment run status type (required)
        :param int maxresults: Maximum number of results to return
        :param int page: Requested page number
        :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[MinimalDeploymentRun], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'search_type', 'maxresults', 'page']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_deployment_runs_in_virtualization_realm"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `get_deployment_runs_in_virtualization_realm`'
                )
        if self.api_client.client_side_validation and ('search_type' not in
            local_var_params or local_var_params['search_type'] is None):
            raise ApiValueError(
                'Missing the required parameter `search_type` when calling `get_deployment_runs_in_virtualization_realm`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        if 'search_type' in local_var_params and local_var_params['search_type'
            ] is not None:
            query_params.append(('search_type', local_var_params[
                'search_type']))
        if 'maxresults' in local_var_params and local_var_params['maxresults'
            ] is not None:
            query_params.append(('maxresults', local_var_params['maxresults']))
        if 'page' in local_var_params and local_var_params['page'] is not None:
            query_params.append(('page', local_var_params['page']))
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/deploymentruns', 'GET',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'list[MinimalDeploymentRun]', auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def get_host_configuration_metrics1(self, id, start, end, **kwargs):
        """Retrieve Metrics  # noqa: E501

        Returns metric data for Deployment Runs launched into the specified Virtualization Realm.  # 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_host_configuration_metrics1(id, start, end, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param int start: Interval start time, specified in seconds since epoch (required)
        :param int end: Interval end time, specified in seconds since epoch (required)
        :param int interval: Number of intervals
        :param str interval_unit: Interval unit
        :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_host_configuration_metrics1_with_http_info(id,
            start, end, **kwargs)
    <mask token>

    def get_network(self, id, network_id, **kwargs):
        """Retrieve Network  # noqa: E501

        Returns a single Network in the specified Virtualization Realm.  # 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_network(id, network_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param int network_id: ID of network (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: Network
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_network_with_http_info(id, network_id, **kwargs)

    def get_network_with_http_info(self, id, network_id, **kwargs):
        """Retrieve Network  # noqa: E501

        Returns a single Network in the specified Virtualization Realm.  # 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_network_with_http_info(id, network_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param int network_id: ID of network (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(Network, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'network_id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_network"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `get_network`'
                )
        if self.api_client.client_side_validation and ('network_id' not in
            local_var_params or local_var_params['network_id'] is None):
            raise ApiValueError(
                'Missing the required parameter `network_id` when calling `get_network`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        if 'network_id' in local_var_params:
            path_params['networkId'] = local_var_params['network_id']
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/networks/{networkId}', 'GET',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'Network', auth_settings=auth_settings, async_req=
            local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)
    <mask token>

    def get_networks_with_http_info(self, id, **kwargs):
        """List Networks  # noqa: E501

        Returns a collection of the Networks in the specified Virtualization Realm.  # 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_networks_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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[MinimalNetwork], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_networks"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `get_networks`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/networks', 'GET', path_params,
            query_params, header_params, body=body_params, post_params=
            form_params, files=local_var_files, response_type=
            'list[MinimalNetwork]', auth_settings=auth_settings, async_req=
            local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)
    <mask token>

    def get_template_subscription_with_http_info(self, id, subscription_id,
        **kwargs):
        """Retrieve Template Subscription  # noqa: E501

        Returns a single Template Subscription in the specified Virtualization Realm.  # 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_template_subscription_with_http_info(id, subscription_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int subscription_id: ID of template subscription (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(FullTemplateSubscription, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'subscription_id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_template_subscription"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `get_template_subscription`'
                )
        if self.api_client.client_side_validation and ('subscription_id' not in
            local_var_params or local_var_params['subscription_id'] is None):
            raise ApiValueError(
                'Missing the required parameter `subscription_id` when calling `get_template_subscription`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        if 'subscription_id' in local_var_params:
            path_params['subscription_id'] = local_var_params['subscription_id'
                ]
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/subscriptions/{subscription_id}'
            , 'GET', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='FullTemplateSubscription', auth_settings=
            auth_settings, async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def get_templates_in_virtualization_realm(self, id, **kwargs):
        """List Templates  # noqa: E501

        Returns a collection of the Templates in the specified Virtualization Realm.  # 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_templates_in_virtualization_realm(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param bool include_registrations: Include templates registered to the virtualization realm
        :param bool include_subscriptions: Include templates subscribed to by the virtualization realm
        :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[MinimalCons3rtTemplateData]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_templates_in_virtualization_realm_with_http_info(id,
            **kwargs)

    def get_templates_in_virtualization_realm_with_http_info(self, id, **kwargs
        ):
        """List Templates  # noqa: E501

        Returns a collection of the Templates in the specified Virtualization Realm.  # 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_templates_in_virtualization_realm_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param bool include_registrations: Include templates registered to the virtualization realm
        :param bool include_subscriptions: Include templates subscribed to by the virtualization realm
        :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[MinimalCons3rtTemplateData], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'include_registrations', 'include_subscriptions']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_templates_in_virtualization_realm"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `get_templates_in_virtualization_realm`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        if 'include_registrations' in local_var_params and local_var_params[
            'include_registrations'] is not None:
            query_params.append(('include_registrations', local_var_params[
                'include_registrations']))
        if 'include_subscriptions' in local_var_params and local_var_params[
            'include_subscriptions'] is not None:
            query_params.append(('include_subscriptions', local_var_params[
                'include_subscriptions']))
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates', 'GET', path_params,
            query_params, header_params, body=body_params, post_params=
            form_params, files=local_var_files, response_type=
            'list[MinimalCons3rtTemplateData]', auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def get_unregistered_networks(self, id, **kwargs):
        """List Unregistered Networks  # noqa: E501

        Returns a collection of the unregistered, back-end Networks in the specified Virtualization Realm.  # 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_unregistered_networks(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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[Subnet]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_unregistered_networks_with_http_info(id, **kwargs)

    def get_unregistered_networks_with_http_info(self, id, **kwargs):
        """List Unregistered Networks  # noqa: E501

        Returns a collection of the unregistered, back-end Networks in the specified Virtualization Realm.  # 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_unregistered_networks_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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[Subnet], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_unregistered_networks"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `get_unregistered_networks`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/networks/unregistered', 'GET',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'list[Subnet]', auth_settings=auth_settings, async_req=
            local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)
    <mask token>

    def get_virtual_machine_count_metrics1_with_http_info(self, id, start,
        end, **kwargs):
        """Retrieve Virtual Machine Metrics  # noqa: E501

        Returns metric data for Virtual Machines launched into the specified Virtualization Realm.  # 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_virtual_machine_count_metrics1_with_http_info(id, start, end, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param int start: Interval start time, specified in seconds since epoch (required)
        :param int end: Interval end time, specified in seconds since epoch (required)
        :param int interval: Number of intervals
        :param str interval_unit: Interval unit
        :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 = ['id', 'start', 'end', 'interval', 'interval_unit']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_virtual_machine_count_metrics1"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `get_virtual_machine_count_metrics1`'
                )
        if self.api_client.client_side_validation and ('start' not in
            local_var_params or local_var_params['start'] is None):
            raise ApiValueError(
                'Missing the required parameter `start` when calling `get_virtual_machine_count_metrics1`'
                )
        if self.api_client.client_side_validation and ('end' not in
            local_var_params or local_var_params['end'] is None):
            raise ApiValueError(
                'Missing the required parameter `end` when calling `get_virtual_machine_count_metrics1`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        if 'start' in local_var_params and local_var_params['start'
            ] is not None:
            query_params.append(('start', local_var_params['start']))
        if 'end' in local_var_params and local_var_params['end'] is not None:
            query_params.append(('end', local_var_params['end']))
        if 'interval' in local_var_params and local_var_params['interval'
            ] is not None:
            query_params.append(('interval', local_var_params['interval']))
        if 'interval_unit' in local_var_params and local_var_params[
            'interval_unit'] is not None:
            query_params.append(('intervalUnit', local_var_params[
                'interval_unit']))
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/metrics/virtualmachinecount',
            'GET', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='str', auth_settings=auth_settings, async_req=
            local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_virtualization_realm(self, id, **kwargs):
        """Retrieve Virtualization Realm  # noqa: E501

        Returns a single Virtualization Realm by the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_virtualization_realm(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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: FullVirtualizationRealm
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_virtualization_realm_with_http_info(id, **kwargs)

    def get_virtualization_realm_with_http_info(self, id, **kwargs):
        """Retrieve Virtualization Realm  # noqa: E501

        Returns a single Virtualization Realm by the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_virtualization_realm_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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(FullVirtualizationRealm, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_virtualization_realm"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `get_virtualization_realm`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api('/api/virtualizationrealms/{id}',
            'GET', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='FullVirtualizationRealm', auth_settings=
            auth_settings, async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def get_virtualization_realm_resources(self, id, **kwargs):
        """Retrieve Virtualization Realm Resources  # noqa: E501

        Returns the back-end resources for a single Virtualization Realm by the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_virtualization_realm_resources(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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: AbstractCloudResources
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_virtualization_realm_resources_with_http_info(id,
            **kwargs)

    def get_virtualization_realm_resources_with_http_info(self, id, **kwargs):
        """Retrieve Virtualization Realm Resources  # noqa: E501

        Returns the back-end resources for a single Virtualization Realm by the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_virtualization_realm_resources_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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(AbstractCloudResources, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_virtualization_realm_resources"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `get_virtualization_realm_resources`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/resources', 'GET', path_params,
            query_params, header_params, body=body_params, post_params=
            form_params, files=local_var_files, response_type=
            'AbstractCloudResources', auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def get_virtualization_realms(self, **kwargs):
        """List Virtualization Realms  # noqa: E501

        Returns a collection of the Virtualization Realms that the user manages.  # 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_virtualization_realms(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int maxresults: Maximum number of results to return
        :param int page: Requested page number
        :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[MinimalVirtualizationRealm]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_virtualization_realms_with_http_info(**kwargs)

    def get_virtualization_realms_with_http_info(self, **kwargs):
        """List Virtualization Realms  # noqa: E501

        Returns a collection of the Virtualization Realms that the user manages.  # 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_virtualization_realms_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int maxresults: Maximum number of results to return
        :param int page: Requested page number
        :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[MinimalVirtualizationRealm], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['maxresults', 'page']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_virtualization_realms"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        collection_formats = {}
        path_params = {}
        query_params = []
        if 'maxresults' in local_var_params and local_var_params['maxresults'
            ] is not None:
            query_params.append(('maxresults', local_var_params['maxresults']))
        if 'page' in local_var_params and local_var_params['page'] is not None:
            query_params.append(('page', local_var_params['page']))
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api('/api/virtualizationrealms', 'GET',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'list[MinimalVirtualizationRealm]', auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def invalidate_template_cache_in_virtualization_realm(self, id, **kwargs):
        """Refresh Template Cache  # noqa: E501

        Forces the back-end Template data to be re-read in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.invalidate_template_cache_in_virtualization_realm(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return (self.
            invalidate_template_cache_in_virtualization_realm_with_http_info
            (id, **kwargs))

    def invalidate_template_cache_in_virtualization_realm_with_http_info(self,
        id, **kwargs):
        """Refresh Template Cache  # noqa: E501

        Forces the back-end Template data to be re-read in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.invalidate_template_cache_in_virtualization_realm_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 invalidate_template_cache_in_virtualization_realm"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `invalidate_template_cache_in_virtualization_realm`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/registrations', 'PUT',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'bool', auth_settings=auth_settings, async_req=local_var_params
            .get('async_req'), _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def list_pending_template_subscriptions(self, id, **kwargs):
        """List Pending Subscriptions  # noqa: E501

        Returns a collection of the pending Template Subscriptions in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_pending_template_subscriptions(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (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[FullTemplateRegistrationForSubscription]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.list_pending_template_subscriptions_with_http_info(id,
            **kwargs)

    def list_pending_template_subscriptions_with_http_info(self, id, **kwargs):
        """List Pending Subscriptions  # noqa: E501

        Returns a collection of the pending Template Subscriptions in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_pending_template_subscriptions_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (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[FullTemplateRegistrationForSubscription], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 list_pending_template_subscriptions"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `list_pending_template_subscriptions`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/subscriptions/pending',
            'GET', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='list[FullTemplateRegistrationForSubscription]',
            auth_settings=auth_settings, async_req=local_var_params.get(
            'async_req'), _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def list_projects(self, id, **kwargs):
        """List Projects  # noqa: E501

        Returns a collection of the Projects allowed to access to the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_projects(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param int maxresults: Maximum number of results to return
        :param int page: Requested page number
        :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[MinimalProject]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.list_projects_with_http_info(id, **kwargs)

    def list_projects_with_http_info(self, id, **kwargs):
        """List Projects  # noqa: E501

        Returns a collection of the Projects allowed to access to the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_projects_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param int maxresults: Maximum number of results to return
        :param int page: Requested page number
        :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[MinimalProject], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'maxresults', 'page']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 list_projects"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `list_projects`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        if 'maxresults' in local_var_params and local_var_params['maxresults'
            ] is not None:
            query_params.append(('maxresults', local_var_params['maxresults']))
        if 'page' in local_var_params and local_var_params['page'] is not None:
            query_params.append(('page', local_var_params['page']))
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/projects', 'GET', path_params,
            query_params, header_params, body=body_params, post_params=
            form_params, files=local_var_files, response_type=
            'list[MinimalProject]', auth_settings=auth_settings, async_req=
            local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)
    <mask token>

    def list_template_registrations_with_http_info(self, id, **kwargs):
        """List Template Registrations  # noqa: E501

        Returns a collection of the Template Registrations in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_template_registrations_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (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[MinimalTemplateRegistration], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 list_template_registrations"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `list_template_registrations`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/registrations', 'GET',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'list[MinimalTemplateRegistration]', auth_settings=
            auth_settings, async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def list_template_subscriptions(self, id, **kwargs):
        """List Template Subscriptions  # noqa: E501

        Returns a collection of the Template Subscriptions in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_template_subscriptions(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (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[MinimalTemplateSubscription]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.list_template_subscriptions_with_http_info(id, **kwargs)

    def list_template_subscriptions_with_http_info(self, id, **kwargs):
        """List Template Subscriptions  # noqa: E501

        Returns a collection of the Template Subscriptions in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_template_subscriptions_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (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[MinimalTemplateSubscription], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 list_template_subscriptions"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `list_template_subscriptions`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/subscriptions', 'GET',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'list[MinimalTemplateSubscription]', auth_settings=
            auth_settings, async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def list_unregistered_templates(self, id, **kwargs):
        """List Unregistered Templates  # noqa: E501

        Returns a collection of the unregistered, back-end Templates in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_unregistered_templates(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (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[Cons3rtTemplateTagData]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.list_unregistered_templates_with_http_info(id, **kwargs)

    def list_unregistered_templates_with_http_info(self, id, **kwargs):
        """List Unregistered Templates  # noqa: E501

        Returns a collection of the unregistered, back-end Templates in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_unregistered_templates_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (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[Cons3rtTemplateTagData], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 list_unregistered_templates"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `list_unregistered_templates`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/registrations/pending',
            'GET', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='list[Cons3rtTemplateTagData]', auth_settings=
            auth_settings, async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def register_network(self, id, network_identifier, **kwargs):
        """Register Network  # noqa: E501

        Adds an existing, back-end Network the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.register_network(id, network_identifier, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param str network_identifier: Back-end network identifier (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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.register_network_with_http_info(id, network_identifier,
            **kwargs)

    def register_network_with_http_info(self, id, network_identifier, **kwargs
        ):
        """Register Network  # noqa: E501

        Adds an existing, back-end Network the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.register_network_with_http_info(id, network_identifier, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param str network_identifier: Back-end network identifier (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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'network_identifier']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 register_network"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `register_network`'
                )
        if self.api_client.client_side_validation and ('network_identifier'
             not in local_var_params or local_var_params[
            'network_identifier'] is None):
            raise ApiValueError(
                'Missing the required parameter `network_identifier` when calling `register_network`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        if 'network_identifier' in local_var_params:
            path_params['networkIdentifier'] = local_var_params[
                'network_identifier']
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/networks/{networkIdentifier}',
            'PUT', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='bool', auth_settings=auth_settings, async_req=
            local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def register_template(self, id, **kwargs):
        """Register Template  # noqa: E501

        Adds an existing back-end Template to the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.register_template(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param InputRegisterTemplateObject input_register_template_object: The template registration data
        :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: FullTemplateRegistration
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.register_template_with_http_info(id, **kwargs)
    <mask token>
    <mask token>

    def remove_project_with_http_info(self, id, project_id, **kwargs):
        """Unassign Project  # noqa: E501

        Revokes Project member access to the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.remove_project_with_http_info(id, project_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param str project_id: ID of project to unassign (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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'project_id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 remove_project"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `remove_project`'
                )
        if self.api_client.client_side_validation and ('project_id' not in
            local_var_params or local_var_params['project_id'] is None):
            raise ApiValueError(
                'Missing the required parameter `project_id` when calling `remove_project`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        if 'project_id' in local_var_params and local_var_params['project_id'
            ] is not None:
            query_params.append(('projectId', local_var_params['project_id']))
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/projects', 'DELETE',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'bool', auth_settings=auth_settings, async_req=local_var_params
            .get('async_req'), _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def retrieve_template_registration(self, id, registration_id, **kwargs):
        """Retrieve Template Registration  # noqa: E501

        Returns a single Template Registration in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_template_registration(id, registration_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (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: FullTemplateRegistration
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.retrieve_template_registration_with_http_info(id,
            registration_id, **kwargs)

    def retrieve_template_registration_with_http_info(self, id,
        registration_id, **kwargs):
        """Retrieve Template Registration  # noqa: E501

        Returns a single Template Registration in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_template_registration_with_http_info(id, registration_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (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(FullTemplateRegistration, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'registration_id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 retrieve_template_registration"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `retrieve_template_registration`'
                )
        if self.api_client.client_side_validation and ('registration_id' not in
            local_var_params or local_var_params['registration_id'] is None):
            raise ApiValueError(
                'Missing the required parameter `registration_id` when calling `retrieve_template_registration`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        if 'registration_id' in local_var_params:
            path_params['registration_id'] = local_var_params['registration_id'
                ]
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/registrations/{registration_id}'
            , 'GET', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='FullTemplateRegistration', auth_settings=
            auth_settings, async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def set_virtualization_realm_active(self, id, activate, **kwargs):
        """Update State  # noqa: E501

        Updates the active State for a single Virtualization Realm by the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.set_virtualization_realm_active(id, activate, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param bool activate: Activate or deactivate virtualization realm (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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.set_virtualization_realm_active_with_http_info(id,
            activate, **kwargs)
    <mask token>
    <mask token>
    <mask token>

    def unregister_template(self, id, registration_id,
        input_unregister_template_object, **kwargs):
        """Delete Template Registration  # noqa: E501

        Removes an existing Template Registration from the specified Virtualization Realm.<br> <br> Note: Unregistering a Template will remove all subscriptions to the Template from other Virtualization Realms.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.unregister_template(id, registration_id, input_unregister_template_object, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (required)
        :param InputUnregisterTemplateObject input_unregister_template_object: The deletion settings (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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.unregister_template_with_http_info(id, registration_id,
            input_unregister_template_object, **kwargs)

    def unregister_template_with_http_info(self, id, registration_id,
        input_unregister_template_object, **kwargs):
        """Delete Template Registration  # noqa: E501

        Removes an existing Template Registration from the specified Virtualization Realm.<br> <br> Note: Unregistering a Template will remove all subscriptions to the Template from other Virtualization Realms.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.unregister_template_with_http_info(id, registration_id, input_unregister_template_object, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (required)
        :param InputUnregisterTemplateObject input_unregister_template_object: The deletion settings (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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'registration_id',
            'input_unregister_template_object']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 unregister_template"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `unregister_template`'
                )
        if self.api_client.client_side_validation and ('registration_id' not in
            local_var_params or local_var_params['registration_id'] is None):
            raise ApiValueError(
                'Missing the required parameter `registration_id` when calling `unregister_template`'
                )
        if self.api_client.client_side_validation and (
            'input_unregister_template_object' not in local_var_params or 
            local_var_params['input_unregister_template_object'] is None):
            raise ApiValueError(
                'Missing the required parameter `input_unregister_template_object` when calling `unregister_template`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        if 'registration_id' in local_var_params:
            path_params['registration_id'] = local_var_params['registration_id'
                ]
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        if 'input_unregister_template_object' in local_var_params:
            body_params = local_var_params['input_unregister_template_object']
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        header_params['Content-Type'
            ] = self.api_client.select_header_content_type([
            'application/json', 'application/xml'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/registrations/{registration_id}'
            , 'DELETE', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='bool', auth_settings=auth_settings, async_req=
            local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def unshare_template_registration(self, id, registration_id,
        target_realm_id, **kwargs):
        """Unshare Template  # noqa: E501

        Revokes access to a Template Registration in the specified Virtualization Realm by the provided external Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.unshare_template_registration(id, registration_id, target_realm_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (required)
        :param int target_realm_id: ID of external virtualization realm to revoke template registration access for (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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.unshare_template_registration_with_http_info(id,
            registration_id, target_realm_id, **kwargs)

    def unshare_template_registration_with_http_info(self, id,
        registration_id, target_realm_id, **kwargs):
        """Unshare Template  # noqa: E501

        Revokes access to a Template Registration in the specified Virtualization Realm by the provided external Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.unshare_template_registration_with_http_info(id, registration_id, target_realm_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (required)
        :param int target_realm_id: ID of external virtualization realm to revoke template registration access for (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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'registration_id', 'target_realm_id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 unshare_template_registration"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `unshare_template_registration`'
                )
        if self.api_client.client_side_validation and ('registration_id' not in
            local_var_params or local_var_params['registration_id'] is None):
            raise ApiValueError(
                'Missing the required parameter `registration_id` when calling `unshare_template_registration`'
                )
        if self.api_client.client_side_validation and ('target_realm_id' not in
            local_var_params or local_var_params['target_realm_id'] is None):
            raise ApiValueError(
                'Missing the required parameter `target_realm_id` when calling `unshare_template_registration`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        if 'registration_id' in local_var_params:
            path_params['registration_id'] = local_var_params['registration_id'
                ]
        query_params = []
        if 'target_realm_id' in local_var_params and local_var_params[
            'target_realm_id'] is not None:
            query_params.append(('target_realm_id', local_var_params[
                'target_realm_id']))
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/registrations/{registration_id}/share'
            , 'DELETE', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='bool', auth_settings=auth_settings, async_req=
            local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)
    <mask token>

    def update_template_registration_with_http_info(self, id,
        registration_id, input_cons3rt_template_data, **kwargs):
        """Update Template Registration  # noqa: E501

        Updates the Template Registration for a single Virtualization Realm by the given ID.<br> <br> Note: The state of a Template Registration can only be set to OFFLINE or PUBLISHED.<br> <br> Note: All fields in Template data are honored on update, therefore any configuration that is desired in the updated Registration should be provided.  # 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_template_registration_with_http_info(id, registration_id, input_cons3rt_template_data, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (required)
        :param InputCons3rtTemplateData input_cons3rt_template_data: The modified template registration data (required)
        :param bool offline: The desired template registration state
        :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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'registration_id',
            'input_cons3rt_template_data', 'offline']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_template_registration"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `update_template_registration`'
                )
        if self.api_client.client_side_validation and ('registration_id' not in
            local_var_params or local_var_params['registration_id'] is None):
            raise ApiValueError(
                'Missing the required parameter `registration_id` when calling `update_template_registration`'
                )
        if self.api_client.client_side_validation and (
            'input_cons3rt_template_data' not in local_var_params or 
            local_var_params['input_cons3rt_template_data'] is None):
            raise ApiValueError(
                'Missing the required parameter `input_cons3rt_template_data` when calling `update_template_registration`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        if 'registration_id' in local_var_params:
            path_params['registration_id'] = local_var_params['registration_id'
                ]
        query_params = []
        if 'offline' in local_var_params and local_var_params['offline'
            ] is not None:
            query_params.append(('offline', local_var_params['offline']))
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        if 'input_cons3rt_template_data' in local_var_params:
            body_params = local_var_params['input_cons3rt_template_data']
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        header_params['Content-Type'
            ] = self.api_client.select_header_content_type([
            'application/json', 'application/xml'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/registrations/{registration_id}'
            , 'PUT', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='bool', auth_settings=auth_settings, async_req=
            local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def update_template_subscription(self, id, subscription_id,
        input_template_subscription, **kwargs):
        """Update Template Subscription  # noqa: E501

        Updates the Template Subscription for a single Virtualization Realm by the given ID.<br> <br> Note: The state of a Template Subscription can only be set to OFFLINE or PUBLISHED.<br> <br> Note: The limits of a Template subscription (CPU, RAM, etc.) cannot exceed the value included in the Registration.  # 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_template_subscription(id, subscription_id, input_template_subscription, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int subscription_id: ID of template subscription (required)
        :param InputTemplateSubscription input_template_subscription: The modified template subscription data (required)
        :param bool offline: The desired template subscription state
        :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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.update_template_subscription_with_http_info(id,
            subscription_id, input_template_subscription, **kwargs)
    <mask token>

    def update_virt_realm_remote_access_config(self, id,
        remote_access_config, **kwargs):
        """Update Remote Access  # noqa: E501

        Updates the Remote Access configuration for a single Virtualization Realm by the given ID.<br> <br> Note: remoteAccessIpAddress cannot be updated if the Virtualization Realm's Remote Access is currently enabled.  # 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_virt_realm_remote_access_config(id, remote_access_config, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param RemoteAccessConfig remote_access_config: The updated remote access configuration (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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.update_virt_realm_remote_access_config_with_http_info(id,
            remote_access_config, **kwargs)

    def update_virt_realm_remote_access_config_with_http_info(self, id,
        remote_access_config, **kwargs):
        """Update Remote Access  # noqa: E501

        Updates the Remote Access configuration for a single Virtualization Realm by the given ID.<br> <br> Note: remoteAccessIpAddress cannot be updated if the Virtualization Realm's Remote Access is currently enabled.  # 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_virt_realm_remote_access_config_with_http_info(id, remote_access_config, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param RemoteAccessConfig remote_access_config: The updated remote access configuration (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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'remote_access_config']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_virt_realm_remote_access_config"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `update_virt_realm_remote_access_config`'
                )
        if self.api_client.client_side_validation and (
            'remote_access_config' not in local_var_params or 
            local_var_params['remote_access_config'] is None):
            raise ApiValueError(
                'Missing the required parameter `remote_access_config` when calling `update_virt_realm_remote_access_config`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        if 'remote_access_config' in local_var_params:
            body_params = local_var_params['remote_access_config']
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        header_params['Content-Type'
            ] = self.api_client.select_header_content_type([
            'application/json', 'application/xml'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/remoteaccess', 'PUT',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'bool', auth_settings=auth_settings, async_req=local_var_params
            .get('async_req'), _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)
    <mask token>

    def update_virtualization_realm_with_http_info(self, id, **kwargs):
        """Update Virtualization Realm  # noqa: E501

        Updates the content of a single Virtualization Realm with the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.update_virtualization_realm_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param InputVRAdminVirtualizationRealm input_vr_admin_virtualization_realm: The updated Virtualization Realm data
        :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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'input_vr_admin_virtualization_realm']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_virtualization_realm"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `update_virtualization_realm`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        if 'input_vr_admin_virtualization_realm' in local_var_params:
            body_params = local_var_params[
                'input_vr_admin_virtualization_realm']
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        header_params['Content-Type'
            ] = self.api_client.select_header_content_type([
            'application/json', 'application/xml'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api('/api/virtualizationrealms/{id}',
            'PUT', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='bool', auth_settings=auth_settings, async_req=
            local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def update_virtualization_realm_reachability(self, id, **kwargs):
        """update_virtualization_realm_reachability  # 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_virtualization_realm_reachability(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.update_virtualization_realm_reachability_with_http_info(id,
            **kwargs)

    def update_virtualization_realm_reachability_with_http_info(self, id,
        **kwargs):
        """update_virtualization_realm_reachability  # 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_virtualization_realm_reachability_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_virtualization_realm_reachability"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `update_virtualization_realm_reachability`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json', 'application/xml'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/updatereachability', 'PUT',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'bool', auth_settings=auth_settings, async_req=local_var_params
            .get('async_req'), _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

<mask token>


class VirtualizationRealmsApi(object):
    <mask token>

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

    def add_network(self, id, abstract_add_network_cloud_space_request, **
        kwargs):
        """Allocate Network  # noqa: E501

        Adds a Network to the specified Virtualization Realm.<br> <br> Since this call results in the construction of a new, back-end Network it has financial implications and should not be used if the user is not prepared to incur the expense of construction and existence of the newly created Network.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.add_network(id, abstract_add_network_cloud_space_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param AbstractAddNetworkCloudSpaceRequest abstract_add_network_cloud_space_request: The network allocation information (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: MinimalVirtualizationRealm
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.add_network_with_http_info(id,
            abstract_add_network_cloud_space_request, **kwargs)

    def add_network_with_http_info(self, id,
        abstract_add_network_cloud_space_request, **kwargs):
        """Allocate Network  # noqa: E501

        Adds a Network to the specified Virtualization Realm.<br> <br> Since this call results in the construction of a new, back-end Network it has financial implications and should not be used if the user is not prepared to incur the expense of construction and existence of the newly created Network.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.add_network_with_http_info(id, abstract_add_network_cloud_space_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param AbstractAddNetworkCloudSpaceRequest abstract_add_network_cloud_space_request: The network allocation information (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(MinimalVirtualizationRealm, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'abstract_add_network_cloud_space_request']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 add_network"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `add_network`'
                )
        if self.api_client.client_side_validation and (
            'abstract_add_network_cloud_space_request' not in
            local_var_params or local_var_params[
            'abstract_add_network_cloud_space_request'] is None):
            raise ApiValueError(
                'Missing the required parameter `abstract_add_network_cloud_space_request` when calling `add_network`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        if 'abstract_add_network_cloud_space_request' in local_var_params:
            body_params = local_var_params[
                'abstract_add_network_cloud_space_request']
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        header_params['Content-Type'
            ] = self.api_client.select_header_content_type([
            'application/json', 'application/xml'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/networks', 'POST', path_params,
            query_params, header_params, body=body_params, post_params=
            form_params, files=local_var_files, response_type=
            'MinimalVirtualizationRealm', auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def add_project(self, id, project_id, **kwargs):
        """Assign Project  # noqa: E501

        Provides members of the Project with access to the specified Virtualization Realm  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.add_project(id, project_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param str project_id: ID of project to assign (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: int
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.add_project_with_http_info(id, project_id, **kwargs)
    <mask token>

    def create_template_subsciption(self, id, registration_id, **kwargs):
        """Create Template Subscription  # noqa: E501

        Creates a Template Subscription in the specified Virtualization Realm.  # 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_template_subsciption(id, registration_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (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: FullTemplateSubscription
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.create_template_subsciption_with_http_info(id,
            registration_id, **kwargs)

    def create_template_subsciption_with_http_info(self, id,
        registration_id, **kwargs):
        """Create Template Subscription  # noqa: E501

        Creates a Template Subscription in the specified Virtualization Realm.  # 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_template_subsciption_with_http_info(id, registration_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (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(FullTemplateSubscription, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'registration_id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_template_subsciption"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `create_template_subsciption`'
                )
        if self.api_client.client_side_validation and ('registration_id' not in
            local_var_params or local_var_params['registration_id'] is None):
            raise ApiValueError(
                'Missing the required parameter `registration_id` when calling `create_template_subsciption`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        if 'registration_id' in local_var_params and local_var_params[
            'registration_id'] is not None:
            query_params.append(('registration_id', local_var_params[
                'registration_id']))
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/subscriptions',
            'POST', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='FullTemplateSubscription', auth_settings=
            auth_settings, async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def delete_network(self, id, network_id, **kwargs):
        """Delete Network  # noqa: E501

        Removes an existing Network from the specified Virtualization Realm.  # 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_network(id, network_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param int network_id: ID of network (required)
        :param bool deallocate: Attempt to delete all back-end resources
        :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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.delete_network_with_http_info(id, network_id, **kwargs)
    <mask token>

    def delete_template_subscription(self, id, subscription_id, **kwargs):
        """Delete Template Subscription  # noqa: E501

        Removes an existing Template Subscription from the specified Virtualization Realm.  # 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_template_subscription(id, subscription_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int subscription_id: ID of template subscription (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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.delete_template_subscription_with_http_info(id,
            subscription_id, **kwargs)

    def delete_template_subscription_with_http_info(self, id,
        subscription_id, **kwargs):
        """Delete Template Subscription  # noqa: E501

        Removes an existing Template Subscription from the specified Virtualization Realm.  # 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_template_subscription_with_http_info(id, subscription_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int subscription_id: ID of template subscription (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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'subscription_id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_template_subscription"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `delete_template_subscription`'
                )
        if self.api_client.client_side_validation and ('subscription_id' not in
            local_var_params or local_var_params['subscription_id'] is None):
            raise ApiValueError(
                'Missing the required parameter `subscription_id` when calling `delete_template_subscription`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        if 'subscription_id' in local_var_params:
            path_params['subscription_id'] = local_var_params['subscription_id'
                ]
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/subscriptions/{subscription_id}'
            , 'DELETE', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='bool', auth_settings=auth_settings, async_req=
            local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def disable_virt_realm_remote_access(self, id, **kwargs):
        """Disable Remote Access  # noqa: E501

        Disables Remote Access for a single Virtualization Realm by the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.disable_virt_realm_remote_access(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.disable_virt_realm_remote_access_with_http_info(id, **
            kwargs)
    <mask token>

    def enable_maintence_mode1(self, id, **kwargs):
        """Update Maintenance Mode  # noqa: E501

        Updates the maintenance status for a single Virtualization Realm by the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.enable_maintence_mode1(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param bool enable: Enable or disable maintenance mode
        :param MaintenanceModeRequest maintenance_mode_request: The maintenance mode request, when enabling maintenance mode
        :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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.enable_maintence_mode1_with_http_info(id, **kwargs)

    def enable_maintence_mode1_with_http_info(self, id, **kwargs):
        """Update Maintenance Mode  # noqa: E501

        Updates the maintenance status for a single Virtualization Realm by the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.enable_maintence_mode1_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param bool enable: Enable or disable maintenance mode
        :param MaintenanceModeRequest maintenance_mode_request: The maintenance mode request, when enabling maintenance mode
        :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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'enable', 'maintenance_mode_request']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 enable_maintence_mode1"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `enable_maintence_mode1`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        if 'enable' in local_var_params and local_var_params['enable'
            ] is not None:
            query_params.append(('enable', local_var_params['enable']))
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        if 'maintenance_mode_request' in local_var_params:
            body_params = local_var_params['maintenance_mode_request']
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        header_params['Content-Type'
            ] = self.api_client.select_header_content_type([
            'application/json', 'application/xml'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/maintenance', 'PUT',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'bool', auth_settings=auth_settings, async_req=local_var_params
            .get('async_req'), _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def enable_virt_realm_remote_access(self, id, **kwargs):
        """Enable Remote Access  # noqa: E501

        Enables Remote Access for a single Virtualization Realm by the given ID.<br> <br> To do so, Remote Access must be configured for the Virtualization Realm.<br> <br> If no instanceType is provided, the Instance Type will first attempt to use the value from the Virtualization Realm's Remote Access config.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.enable_virt_realm_remote_access(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param str instance_type: Remote access server instance type
        :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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.enable_virt_realm_remote_access_with_http_info(id, **kwargs
            )

    def enable_virt_realm_remote_access_with_http_info(self, id, **kwargs):
        """Enable Remote Access  # noqa: E501

        Enables Remote Access for a single Virtualization Realm by the given ID.<br> <br> To do so, Remote Access must be configured for the Virtualization Realm.<br> <br> If no instanceType is provided, the Instance Type will first attempt to use the value from the Virtualization Realm's Remote Access config.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.enable_virt_realm_remote_access_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param str instance_type: Remote access server instance type
        :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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'instance_type']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 enable_virt_realm_remote_access"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `enable_virt_realm_remote_access`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        if 'instance_type' in local_var_params and local_var_params[
            'instance_type'] is not None:
            query_params.append(('instanceType', local_var_params[
                'instance_type']))
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/remoteaccess', 'POST',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'bool', auth_settings=auth_settings, async_req=local_var_params
            .get('async_req'), _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def get_deployment_runs_in_virtualization_realm(self, id, search_type,
        **kwargs):
        """List Deployment Runs  # noqa: E501

        Returns a collection of the Deployment Runs launched into the specified Virtualization Realm.  # 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_deployment_runs_in_virtualization_realm(id, search_type, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param str search_type: Deployment run status type (required)
        :param int maxresults: Maximum number of results to return
        :param int page: Requested page number
        :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[MinimalDeploymentRun]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_deployment_runs_in_virtualization_realm_with_http_info(
            id, search_type, **kwargs)

    def get_deployment_runs_in_virtualization_realm_with_http_info(self, id,
        search_type, **kwargs):
        """List Deployment Runs  # noqa: E501

        Returns a collection of the Deployment Runs launched into the specified Virtualization Realm.  # 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_deployment_runs_in_virtualization_realm_with_http_info(id, search_type, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param str search_type: Deployment run status type (required)
        :param int maxresults: Maximum number of results to return
        :param int page: Requested page number
        :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[MinimalDeploymentRun], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'search_type', 'maxresults', 'page']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_deployment_runs_in_virtualization_realm"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `get_deployment_runs_in_virtualization_realm`'
                )
        if self.api_client.client_side_validation and ('search_type' not in
            local_var_params or local_var_params['search_type'] is None):
            raise ApiValueError(
                'Missing the required parameter `search_type` when calling `get_deployment_runs_in_virtualization_realm`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        if 'search_type' in local_var_params and local_var_params['search_type'
            ] is not None:
            query_params.append(('search_type', local_var_params[
                'search_type']))
        if 'maxresults' in local_var_params and local_var_params['maxresults'
            ] is not None:
            query_params.append(('maxresults', local_var_params['maxresults']))
        if 'page' in local_var_params and local_var_params['page'] is not None:
            query_params.append(('page', local_var_params['page']))
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/deploymentruns', 'GET',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'list[MinimalDeploymentRun]', auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def get_host_configuration_metrics1(self, id, start, end, **kwargs):
        """Retrieve Metrics  # noqa: E501

        Returns metric data for Deployment Runs launched into the specified Virtualization Realm.  # 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_host_configuration_metrics1(id, start, end, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param int start: Interval start time, specified in seconds since epoch (required)
        :param int end: Interval end time, specified in seconds since epoch (required)
        :param int interval: Number of intervals
        :param str interval_unit: Interval unit
        :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_host_configuration_metrics1_with_http_info(id,
            start, end, **kwargs)

    def get_host_configuration_metrics1_with_http_info(self, id, start, end,
        **kwargs):
        """Retrieve Metrics  # noqa: E501

        Returns metric data for Deployment Runs launched into the specified Virtualization Realm.  # 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_host_configuration_metrics1_with_http_info(id, start, end, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param int start: Interval start time, specified in seconds since epoch (required)
        :param int end: Interval end time, specified in seconds since epoch (required)
        :param int interval: Number of intervals
        :param str interval_unit: Interval unit
        :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 = ['id', 'start', 'end', 'interval', 'interval_unit']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_host_configuration_metrics1"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `get_host_configuration_metrics1`'
                )
        if self.api_client.client_side_validation and ('start' not in
            local_var_params or local_var_params['start'] is None):
            raise ApiValueError(
                'Missing the required parameter `start` when calling `get_host_configuration_metrics1`'
                )
        if self.api_client.client_side_validation and ('end' not in
            local_var_params or local_var_params['end'] is None):
            raise ApiValueError(
                'Missing the required parameter `end` when calling `get_host_configuration_metrics1`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        if 'start' in local_var_params and local_var_params['start'
            ] is not None:
            query_params.append(('start', local_var_params['start']))
        if 'end' in local_var_params and local_var_params['end'] is not None:
            query_params.append(('end', local_var_params['end']))
        if 'interval' in local_var_params and local_var_params['interval'
            ] is not None:
            query_params.append(('interval', local_var_params['interval']))
        if 'interval_unit' in local_var_params and local_var_params[
            'interval_unit'] is not None:
            query_params.append(('intervalUnit', local_var_params[
                'interval_unit']))
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/metrics/hostconfiguration',
            'GET', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='str', auth_settings=auth_settings, async_req=
            local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_network(self, id, network_id, **kwargs):
        """Retrieve Network  # noqa: E501

        Returns a single Network in the specified Virtualization Realm.  # 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_network(id, network_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param int network_id: ID of network (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: Network
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_network_with_http_info(id, network_id, **kwargs)

    def get_network_with_http_info(self, id, network_id, **kwargs):
        """Retrieve Network  # noqa: E501

        Returns a single Network in the specified Virtualization Realm.  # 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_network_with_http_info(id, network_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param int network_id: ID of network (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(Network, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'network_id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_network"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `get_network`'
                )
        if self.api_client.client_side_validation and ('network_id' not in
            local_var_params or local_var_params['network_id'] is None):
            raise ApiValueError(
                'Missing the required parameter `network_id` when calling `get_network`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        if 'network_id' in local_var_params:
            path_params['networkId'] = local_var_params['network_id']
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/networks/{networkId}', 'GET',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'Network', auth_settings=auth_settings, async_req=
            local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_networks(self, id, **kwargs):
        """List Networks  # noqa: E501

        Returns a collection of the Networks in the specified Virtualization Realm.  # 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_networks(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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[MinimalNetwork]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_networks_with_http_info(id, **kwargs)

    def get_networks_with_http_info(self, id, **kwargs):
        """List Networks  # noqa: E501

        Returns a collection of the Networks in the specified Virtualization Realm.  # 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_networks_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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[MinimalNetwork], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_networks"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `get_networks`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/networks', 'GET', path_params,
            query_params, header_params, body=body_params, post_params=
            form_params, files=local_var_files, response_type=
            'list[MinimalNetwork]', auth_settings=auth_settings, async_req=
            local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)
    <mask token>

    def get_template_subscription_with_http_info(self, id, subscription_id,
        **kwargs):
        """Retrieve Template Subscription  # noqa: E501

        Returns a single Template Subscription in the specified Virtualization Realm.  # 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_template_subscription_with_http_info(id, subscription_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int subscription_id: ID of template subscription (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(FullTemplateSubscription, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'subscription_id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_template_subscription"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `get_template_subscription`'
                )
        if self.api_client.client_side_validation and ('subscription_id' not in
            local_var_params or local_var_params['subscription_id'] is None):
            raise ApiValueError(
                'Missing the required parameter `subscription_id` when calling `get_template_subscription`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        if 'subscription_id' in local_var_params:
            path_params['subscription_id'] = local_var_params['subscription_id'
                ]
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/subscriptions/{subscription_id}'
            , 'GET', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='FullTemplateSubscription', auth_settings=
            auth_settings, async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def get_templates_in_virtualization_realm(self, id, **kwargs):
        """List Templates  # noqa: E501

        Returns a collection of the Templates in the specified Virtualization Realm.  # 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_templates_in_virtualization_realm(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param bool include_registrations: Include templates registered to the virtualization realm
        :param bool include_subscriptions: Include templates subscribed to by the virtualization realm
        :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[MinimalCons3rtTemplateData]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_templates_in_virtualization_realm_with_http_info(id,
            **kwargs)

    def get_templates_in_virtualization_realm_with_http_info(self, id, **kwargs
        ):
        """List Templates  # noqa: E501

        Returns a collection of the Templates in the specified Virtualization Realm.  # 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_templates_in_virtualization_realm_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param bool include_registrations: Include templates registered to the virtualization realm
        :param bool include_subscriptions: Include templates subscribed to by the virtualization realm
        :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[MinimalCons3rtTemplateData], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'include_registrations', 'include_subscriptions']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_templates_in_virtualization_realm"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `get_templates_in_virtualization_realm`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        if 'include_registrations' in local_var_params and local_var_params[
            'include_registrations'] is not None:
            query_params.append(('include_registrations', local_var_params[
                'include_registrations']))
        if 'include_subscriptions' in local_var_params and local_var_params[
            'include_subscriptions'] is not None:
            query_params.append(('include_subscriptions', local_var_params[
                'include_subscriptions']))
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates', 'GET', path_params,
            query_params, header_params, body=body_params, post_params=
            form_params, files=local_var_files, response_type=
            'list[MinimalCons3rtTemplateData]', auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def get_unregistered_networks(self, id, **kwargs):
        """List Unregistered Networks  # noqa: E501

        Returns a collection of the unregistered, back-end Networks in the specified Virtualization Realm.  # 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_unregistered_networks(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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[Subnet]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_unregistered_networks_with_http_info(id, **kwargs)

    def get_unregistered_networks_with_http_info(self, id, **kwargs):
        """List Unregistered Networks  # noqa: E501

        Returns a collection of the unregistered, back-end Networks in the specified Virtualization Realm.  # 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_unregistered_networks_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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[Subnet], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_unregistered_networks"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `get_unregistered_networks`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/networks/unregistered', 'GET',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'list[Subnet]', auth_settings=auth_settings, async_req=
            local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_virtual_machine_count_metrics1(self, id, start, end, **kwargs):
        """Retrieve Virtual Machine Metrics  # noqa: E501

        Returns metric data for Virtual Machines launched into the specified Virtualization Realm.  # 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_virtual_machine_count_metrics1(id, start, end, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param int start: Interval start time, specified in seconds since epoch (required)
        :param int end: Interval end time, specified in seconds since epoch (required)
        :param int interval: Number of intervals
        :param str interval_unit: Interval unit
        :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_virtual_machine_count_metrics1_with_http_info(id,
            start, end, **kwargs)

    def get_virtual_machine_count_metrics1_with_http_info(self, id, start,
        end, **kwargs):
        """Retrieve Virtual Machine Metrics  # noqa: E501

        Returns metric data for Virtual Machines launched into the specified Virtualization Realm.  # 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_virtual_machine_count_metrics1_with_http_info(id, start, end, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param int start: Interval start time, specified in seconds since epoch (required)
        :param int end: Interval end time, specified in seconds since epoch (required)
        :param int interval: Number of intervals
        :param str interval_unit: Interval unit
        :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 = ['id', 'start', 'end', 'interval', 'interval_unit']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_virtual_machine_count_metrics1"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `get_virtual_machine_count_metrics1`'
                )
        if self.api_client.client_side_validation and ('start' not in
            local_var_params or local_var_params['start'] is None):
            raise ApiValueError(
                'Missing the required parameter `start` when calling `get_virtual_machine_count_metrics1`'
                )
        if self.api_client.client_side_validation and ('end' not in
            local_var_params or local_var_params['end'] is None):
            raise ApiValueError(
                'Missing the required parameter `end` when calling `get_virtual_machine_count_metrics1`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        if 'start' in local_var_params and local_var_params['start'
            ] is not None:
            query_params.append(('start', local_var_params['start']))
        if 'end' in local_var_params and local_var_params['end'] is not None:
            query_params.append(('end', local_var_params['end']))
        if 'interval' in local_var_params and local_var_params['interval'
            ] is not None:
            query_params.append(('interval', local_var_params['interval']))
        if 'interval_unit' in local_var_params and local_var_params[
            'interval_unit'] is not None:
            query_params.append(('intervalUnit', local_var_params[
                'interval_unit']))
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/metrics/virtualmachinecount',
            'GET', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='str', auth_settings=auth_settings, async_req=
            local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_virtualization_realm(self, id, **kwargs):
        """Retrieve Virtualization Realm  # noqa: E501

        Returns a single Virtualization Realm by the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_virtualization_realm(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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: FullVirtualizationRealm
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_virtualization_realm_with_http_info(id, **kwargs)

    def get_virtualization_realm_with_http_info(self, id, **kwargs):
        """Retrieve Virtualization Realm  # noqa: E501

        Returns a single Virtualization Realm by the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_virtualization_realm_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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(FullVirtualizationRealm, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_virtualization_realm"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `get_virtualization_realm`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api('/api/virtualizationrealms/{id}',
            'GET', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='FullVirtualizationRealm', auth_settings=
            auth_settings, async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def get_virtualization_realm_resources(self, id, **kwargs):
        """Retrieve Virtualization Realm Resources  # noqa: E501

        Returns the back-end resources for a single Virtualization Realm by the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_virtualization_realm_resources(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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: AbstractCloudResources
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_virtualization_realm_resources_with_http_info(id,
            **kwargs)

    def get_virtualization_realm_resources_with_http_info(self, id, **kwargs):
        """Retrieve Virtualization Realm Resources  # noqa: E501

        Returns the back-end resources for a single Virtualization Realm by the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_virtualization_realm_resources_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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(AbstractCloudResources, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_virtualization_realm_resources"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `get_virtualization_realm_resources`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/resources', 'GET', path_params,
            query_params, header_params, body=body_params, post_params=
            form_params, files=local_var_files, response_type=
            'AbstractCloudResources', auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def get_virtualization_realms(self, **kwargs):
        """List Virtualization Realms  # noqa: E501

        Returns a collection of the Virtualization Realms that the user manages.  # 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_virtualization_realms(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int maxresults: Maximum number of results to return
        :param int page: Requested page number
        :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[MinimalVirtualizationRealm]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_virtualization_realms_with_http_info(**kwargs)

    def get_virtualization_realms_with_http_info(self, **kwargs):
        """List Virtualization Realms  # noqa: E501

        Returns a collection of the Virtualization Realms that the user manages.  # 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_virtualization_realms_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int maxresults: Maximum number of results to return
        :param int page: Requested page number
        :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[MinimalVirtualizationRealm], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['maxresults', 'page']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_virtualization_realms"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        collection_formats = {}
        path_params = {}
        query_params = []
        if 'maxresults' in local_var_params and local_var_params['maxresults'
            ] is not None:
            query_params.append(('maxresults', local_var_params['maxresults']))
        if 'page' in local_var_params and local_var_params['page'] is not None:
            query_params.append(('page', local_var_params['page']))
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api('/api/virtualizationrealms', 'GET',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'list[MinimalVirtualizationRealm]', auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def invalidate_template_cache_in_virtualization_realm(self, id, **kwargs):
        """Refresh Template Cache  # noqa: E501

        Forces the back-end Template data to be re-read in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.invalidate_template_cache_in_virtualization_realm(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return (self.
            invalidate_template_cache_in_virtualization_realm_with_http_info
            (id, **kwargs))

    def invalidate_template_cache_in_virtualization_realm_with_http_info(self,
        id, **kwargs):
        """Refresh Template Cache  # noqa: E501

        Forces the back-end Template data to be re-read in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.invalidate_template_cache_in_virtualization_realm_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 invalidate_template_cache_in_virtualization_realm"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `invalidate_template_cache_in_virtualization_realm`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/registrations', 'PUT',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'bool', auth_settings=auth_settings, async_req=local_var_params
            .get('async_req'), _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def list_pending_template_subscriptions(self, id, **kwargs):
        """List Pending Subscriptions  # noqa: E501

        Returns a collection of the pending Template Subscriptions in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_pending_template_subscriptions(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (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[FullTemplateRegistrationForSubscription]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.list_pending_template_subscriptions_with_http_info(id,
            **kwargs)

    def list_pending_template_subscriptions_with_http_info(self, id, **kwargs):
        """List Pending Subscriptions  # noqa: E501

        Returns a collection of the pending Template Subscriptions in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_pending_template_subscriptions_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (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[FullTemplateRegistrationForSubscription], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 list_pending_template_subscriptions"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `list_pending_template_subscriptions`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/subscriptions/pending',
            'GET', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='list[FullTemplateRegistrationForSubscription]',
            auth_settings=auth_settings, async_req=local_var_params.get(
            'async_req'), _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def list_projects(self, id, **kwargs):
        """List Projects  # noqa: E501

        Returns a collection of the Projects allowed to access to the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_projects(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param int maxresults: Maximum number of results to return
        :param int page: Requested page number
        :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[MinimalProject]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.list_projects_with_http_info(id, **kwargs)

    def list_projects_with_http_info(self, id, **kwargs):
        """List Projects  # noqa: E501

        Returns a collection of the Projects allowed to access to the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_projects_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param int maxresults: Maximum number of results to return
        :param int page: Requested page number
        :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[MinimalProject], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'maxresults', 'page']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 list_projects"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `list_projects`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        if 'maxresults' in local_var_params and local_var_params['maxresults'
            ] is not None:
            query_params.append(('maxresults', local_var_params['maxresults']))
        if 'page' in local_var_params and local_var_params['page'] is not None:
            query_params.append(('page', local_var_params['page']))
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/projects', 'GET', path_params,
            query_params, header_params, body=body_params, post_params=
            form_params, files=local_var_files, response_type=
            'list[MinimalProject]', auth_settings=auth_settings, async_req=
            local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)
    <mask token>

    def list_template_registrations_with_http_info(self, id, **kwargs):
        """List Template Registrations  # noqa: E501

        Returns a collection of the Template Registrations in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_template_registrations_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (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[MinimalTemplateRegistration], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 list_template_registrations"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `list_template_registrations`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/registrations', 'GET',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'list[MinimalTemplateRegistration]', auth_settings=
            auth_settings, async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def list_template_subscriptions(self, id, **kwargs):
        """List Template Subscriptions  # noqa: E501

        Returns a collection of the Template Subscriptions in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_template_subscriptions(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (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[MinimalTemplateSubscription]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.list_template_subscriptions_with_http_info(id, **kwargs)

    def list_template_subscriptions_with_http_info(self, id, **kwargs):
        """List Template Subscriptions  # noqa: E501

        Returns a collection of the Template Subscriptions in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_template_subscriptions_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (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[MinimalTemplateSubscription], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 list_template_subscriptions"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `list_template_subscriptions`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/subscriptions', 'GET',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'list[MinimalTemplateSubscription]', auth_settings=
            auth_settings, async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def list_unregistered_templates(self, id, **kwargs):
        """List Unregistered Templates  # noqa: E501

        Returns a collection of the unregistered, back-end Templates in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_unregistered_templates(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (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[Cons3rtTemplateTagData]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.list_unregistered_templates_with_http_info(id, **kwargs)

    def list_unregistered_templates_with_http_info(self, id, **kwargs):
        """List Unregistered Templates  # noqa: E501

        Returns a collection of the unregistered, back-end Templates in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_unregistered_templates_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (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[Cons3rtTemplateTagData], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 list_unregistered_templates"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `list_unregistered_templates`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/registrations/pending',
            'GET', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='list[Cons3rtTemplateTagData]', auth_settings=
            auth_settings, async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def register_network(self, id, network_identifier, **kwargs):
        """Register Network  # noqa: E501

        Adds an existing, back-end Network the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.register_network(id, network_identifier, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param str network_identifier: Back-end network identifier (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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.register_network_with_http_info(id, network_identifier,
            **kwargs)

    def register_network_with_http_info(self, id, network_identifier, **kwargs
        ):
        """Register Network  # noqa: E501

        Adds an existing, back-end Network the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.register_network_with_http_info(id, network_identifier, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param str network_identifier: Back-end network identifier (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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'network_identifier']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 register_network"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `register_network`'
                )
        if self.api_client.client_side_validation and ('network_identifier'
             not in local_var_params or local_var_params[
            'network_identifier'] is None):
            raise ApiValueError(
                'Missing the required parameter `network_identifier` when calling `register_network`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        if 'network_identifier' in local_var_params:
            path_params['networkIdentifier'] = local_var_params[
                'network_identifier']
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/networks/{networkIdentifier}',
            'PUT', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='bool', auth_settings=auth_settings, async_req=
            local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def register_template(self, id, **kwargs):
        """Register Template  # noqa: E501

        Adds an existing back-end Template to the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.register_template(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param InputRegisterTemplateObject input_register_template_object: The template registration data
        :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: FullTemplateRegistration
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.register_template_with_http_info(id, **kwargs)
    <mask token>
    <mask token>

    def remove_project_with_http_info(self, id, project_id, **kwargs):
        """Unassign Project  # noqa: E501

        Revokes Project member access to the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.remove_project_with_http_info(id, project_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param str project_id: ID of project to unassign (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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'project_id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 remove_project"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `remove_project`'
                )
        if self.api_client.client_side_validation and ('project_id' not in
            local_var_params or local_var_params['project_id'] is None):
            raise ApiValueError(
                'Missing the required parameter `project_id` when calling `remove_project`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        if 'project_id' in local_var_params and local_var_params['project_id'
            ] is not None:
            query_params.append(('projectId', local_var_params['project_id']))
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/projects', 'DELETE',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'bool', auth_settings=auth_settings, async_req=local_var_params
            .get('async_req'), _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def retrieve_template_registration(self, id, registration_id, **kwargs):
        """Retrieve Template Registration  # noqa: E501

        Returns a single Template Registration in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_template_registration(id, registration_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (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: FullTemplateRegistration
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.retrieve_template_registration_with_http_info(id,
            registration_id, **kwargs)

    def retrieve_template_registration_with_http_info(self, id,
        registration_id, **kwargs):
        """Retrieve Template Registration  # noqa: E501

        Returns a single Template Registration in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_template_registration_with_http_info(id, registration_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (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(FullTemplateRegistration, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'registration_id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 retrieve_template_registration"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `retrieve_template_registration`'
                )
        if self.api_client.client_side_validation and ('registration_id' not in
            local_var_params or local_var_params['registration_id'] is None):
            raise ApiValueError(
                'Missing the required parameter `registration_id` when calling `retrieve_template_registration`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        if 'registration_id' in local_var_params:
            path_params['registration_id'] = local_var_params['registration_id'
                ]
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/registrations/{registration_id}'
            , 'GET', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='FullTemplateRegistration', auth_settings=
            auth_settings, async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def set_virtualization_realm_active(self, id, activate, **kwargs):
        """Update State  # noqa: E501

        Updates the active State for a single Virtualization Realm by the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.set_virtualization_realm_active(id, activate, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param bool activate: Activate or deactivate virtualization realm (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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.set_virtualization_realm_active_with_http_info(id,
            activate, **kwargs)

    def set_virtualization_realm_active_with_http_info(self, id, activate,
        **kwargs):
        """Update State  # noqa: E501

        Updates the active State for a single Virtualization Realm by the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.set_virtualization_realm_active_with_http_info(id, activate, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param bool activate: Activate or deactivate virtualization realm (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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'activate']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 set_virtualization_realm_active"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `set_virtualization_realm_active`'
                )
        if self.api_client.client_side_validation and ('activate' not in
            local_var_params or local_var_params['activate'] is None):
            raise ApiValueError(
                'Missing the required parameter `activate` when calling `set_virtualization_realm_active`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        if 'activate' in local_var_params and local_var_params['activate'
            ] is not None:
            query_params.append(('activate', local_var_params['activate']))
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/activate', 'PUT', path_params,
            query_params, header_params, body=body_params, post_params=
            form_params, files=local_var_files, response_type='bool',
            auth_settings=auth_settings, async_req=local_var_params.get(
            'async_req'), _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def share_template_registration(self, id, registration_id,
        target_realm_ids, **kwargs):
        """Share Template  # noqa: E501

        Shares an existing Template Registration in the specified Virtualization Realm to the provided external Virtualization Realm(s).  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.share_template_registration(id, registration_id, target_realm_ids, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (required)
        :param list[int] target_realm_ids: ID(s) of external virtualization realms to share template registration with (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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.share_template_registration_with_http_info(id,
            registration_id, target_realm_ids, **kwargs)

    def share_template_registration_with_http_info(self, id,
        registration_id, target_realm_ids, **kwargs):
        """Share Template  # noqa: E501

        Shares an existing Template Registration in the specified Virtualization Realm to the provided external Virtualization Realm(s).  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.share_template_registration_with_http_info(id, registration_id, target_realm_ids, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (required)
        :param list[int] target_realm_ids: ID(s) of external virtualization realms to share template registration with (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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'registration_id', 'target_realm_ids']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 share_template_registration"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `share_template_registration`'
                )
        if self.api_client.client_side_validation and ('registration_id' not in
            local_var_params or local_var_params['registration_id'] is None):
            raise ApiValueError(
                'Missing the required parameter `registration_id` when calling `share_template_registration`'
                )
        if self.api_client.client_side_validation and ('target_realm_ids'
             not in local_var_params or local_var_params['target_realm_ids'
            ] is None):
            raise ApiValueError(
                'Missing the required parameter `target_realm_ids` when calling `share_template_registration`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        if 'registration_id' in local_var_params:
            path_params['registration_id'] = local_var_params['registration_id'
                ]
        query_params = []
        if 'target_realm_ids' in local_var_params and local_var_params[
            'target_realm_ids'] is not None:
            query_params.append(('target_realm_ids', local_var_params[
                'target_realm_ids']))
            collection_formats['target_realm_ids'] = 'multi'
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/registrations/{registration_id}/share'
            , 'POST', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='bool', auth_settings=auth_settings, async_req=
            local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def unregister_template(self, id, registration_id,
        input_unregister_template_object, **kwargs):
        """Delete Template Registration  # noqa: E501

        Removes an existing Template Registration from the specified Virtualization Realm.<br> <br> Note: Unregistering a Template will remove all subscriptions to the Template from other Virtualization Realms.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.unregister_template(id, registration_id, input_unregister_template_object, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (required)
        :param InputUnregisterTemplateObject input_unregister_template_object: The deletion settings (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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.unregister_template_with_http_info(id, registration_id,
            input_unregister_template_object, **kwargs)

    def unregister_template_with_http_info(self, id, registration_id,
        input_unregister_template_object, **kwargs):
        """Delete Template Registration  # noqa: E501

        Removes an existing Template Registration from the specified Virtualization Realm.<br> <br> Note: Unregistering a Template will remove all subscriptions to the Template from other Virtualization Realms.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.unregister_template_with_http_info(id, registration_id, input_unregister_template_object, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (required)
        :param InputUnregisterTemplateObject input_unregister_template_object: The deletion settings (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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'registration_id',
            'input_unregister_template_object']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 unregister_template"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `unregister_template`'
                )
        if self.api_client.client_side_validation and ('registration_id' not in
            local_var_params or local_var_params['registration_id'] is None):
            raise ApiValueError(
                'Missing the required parameter `registration_id` when calling `unregister_template`'
                )
        if self.api_client.client_side_validation and (
            'input_unregister_template_object' not in local_var_params or 
            local_var_params['input_unregister_template_object'] is None):
            raise ApiValueError(
                'Missing the required parameter `input_unregister_template_object` when calling `unregister_template`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        if 'registration_id' in local_var_params:
            path_params['registration_id'] = local_var_params['registration_id'
                ]
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        if 'input_unregister_template_object' in local_var_params:
            body_params = local_var_params['input_unregister_template_object']
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        header_params['Content-Type'
            ] = self.api_client.select_header_content_type([
            'application/json', 'application/xml'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/registrations/{registration_id}'
            , 'DELETE', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='bool', auth_settings=auth_settings, async_req=
            local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def unshare_template_registration(self, id, registration_id,
        target_realm_id, **kwargs):
        """Unshare Template  # noqa: E501

        Revokes access to a Template Registration in the specified Virtualization Realm by the provided external Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.unshare_template_registration(id, registration_id, target_realm_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (required)
        :param int target_realm_id: ID of external virtualization realm to revoke template registration access for (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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.unshare_template_registration_with_http_info(id,
            registration_id, target_realm_id, **kwargs)

    def unshare_template_registration_with_http_info(self, id,
        registration_id, target_realm_id, **kwargs):
        """Unshare Template  # noqa: E501

        Revokes access to a Template Registration in the specified Virtualization Realm by the provided external Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.unshare_template_registration_with_http_info(id, registration_id, target_realm_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (required)
        :param int target_realm_id: ID of external virtualization realm to revoke template registration access for (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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'registration_id', 'target_realm_id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 unshare_template_registration"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `unshare_template_registration`'
                )
        if self.api_client.client_side_validation and ('registration_id' not in
            local_var_params or local_var_params['registration_id'] is None):
            raise ApiValueError(
                'Missing the required parameter `registration_id` when calling `unshare_template_registration`'
                )
        if self.api_client.client_side_validation and ('target_realm_id' not in
            local_var_params or local_var_params['target_realm_id'] is None):
            raise ApiValueError(
                'Missing the required parameter `target_realm_id` when calling `unshare_template_registration`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        if 'registration_id' in local_var_params:
            path_params['registration_id'] = local_var_params['registration_id'
                ]
        query_params = []
        if 'target_realm_id' in local_var_params and local_var_params[
            'target_realm_id'] is not None:
            query_params.append(('target_realm_id', local_var_params[
                'target_realm_id']))
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/registrations/{registration_id}/share'
            , 'DELETE', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='bool', auth_settings=auth_settings, async_req=
            local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)
    <mask token>

    def update_template_registration_with_http_info(self, id,
        registration_id, input_cons3rt_template_data, **kwargs):
        """Update Template Registration  # noqa: E501

        Updates the Template Registration for a single Virtualization Realm by the given ID.<br> <br> Note: The state of a Template Registration can only be set to OFFLINE or PUBLISHED.<br> <br> Note: All fields in Template data are honored on update, therefore any configuration that is desired in the updated Registration should be provided.  # 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_template_registration_with_http_info(id, registration_id, input_cons3rt_template_data, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (required)
        :param InputCons3rtTemplateData input_cons3rt_template_data: The modified template registration data (required)
        :param bool offline: The desired template registration state
        :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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'registration_id',
            'input_cons3rt_template_data', 'offline']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_template_registration"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `update_template_registration`'
                )
        if self.api_client.client_side_validation and ('registration_id' not in
            local_var_params or local_var_params['registration_id'] is None):
            raise ApiValueError(
                'Missing the required parameter `registration_id` when calling `update_template_registration`'
                )
        if self.api_client.client_side_validation and (
            'input_cons3rt_template_data' not in local_var_params or 
            local_var_params['input_cons3rt_template_data'] is None):
            raise ApiValueError(
                'Missing the required parameter `input_cons3rt_template_data` when calling `update_template_registration`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        if 'registration_id' in local_var_params:
            path_params['registration_id'] = local_var_params['registration_id'
                ]
        query_params = []
        if 'offline' in local_var_params and local_var_params['offline'
            ] is not None:
            query_params.append(('offline', local_var_params['offline']))
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        if 'input_cons3rt_template_data' in local_var_params:
            body_params = local_var_params['input_cons3rt_template_data']
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        header_params['Content-Type'
            ] = self.api_client.select_header_content_type([
            'application/json', 'application/xml'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/registrations/{registration_id}'
            , 'PUT', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='bool', auth_settings=auth_settings, async_req=
            local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def update_template_subscription(self, id, subscription_id,
        input_template_subscription, **kwargs):
        """Update Template Subscription  # noqa: E501

        Updates the Template Subscription for a single Virtualization Realm by the given ID.<br> <br> Note: The state of a Template Subscription can only be set to OFFLINE or PUBLISHED.<br> <br> Note: The limits of a Template subscription (CPU, RAM, etc.) cannot exceed the value included in the Registration.  # 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_template_subscription(id, subscription_id, input_template_subscription, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int subscription_id: ID of template subscription (required)
        :param InputTemplateSubscription input_template_subscription: The modified template subscription data (required)
        :param bool offline: The desired template subscription state
        :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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.update_template_subscription_with_http_info(id,
            subscription_id, input_template_subscription, **kwargs)

    def update_template_subscription_with_http_info(self, id,
        subscription_id, input_template_subscription, **kwargs):
        """Update Template Subscription  # noqa: E501

        Updates the Template Subscription for a single Virtualization Realm by the given ID.<br> <br> Note: The state of a Template Subscription can only be set to OFFLINE or PUBLISHED.<br> <br> Note: The limits of a Template subscription (CPU, RAM, etc.) cannot exceed the value included in the Registration.  # 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_template_subscription_with_http_info(id, subscription_id, input_template_subscription, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int subscription_id: ID of template subscription (required)
        :param InputTemplateSubscription input_template_subscription: The modified template subscription data (required)
        :param bool offline: The desired template subscription state
        :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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'subscription_id',
            'input_template_subscription', 'offline']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_template_subscription"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `update_template_subscription`'
                )
        if self.api_client.client_side_validation and ('subscription_id' not in
            local_var_params or local_var_params['subscription_id'] is None):
            raise ApiValueError(
                'Missing the required parameter `subscription_id` when calling `update_template_subscription`'
                )
        if self.api_client.client_side_validation and (
            'input_template_subscription' not in local_var_params or 
            local_var_params['input_template_subscription'] is None):
            raise ApiValueError(
                'Missing the required parameter `input_template_subscription` when calling `update_template_subscription`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        if 'subscription_id' in local_var_params:
            path_params['subscription_id'] = local_var_params['subscription_id'
                ]
        query_params = []
        if 'offline' in local_var_params and local_var_params['offline'
            ] is not None:
            query_params.append(('offline', local_var_params['offline']))
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        if 'input_template_subscription' in local_var_params:
            body_params = local_var_params['input_template_subscription']
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        header_params['Content-Type'
            ] = self.api_client.select_header_content_type([
            'application/json', 'application/xml'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/subscriptions/{subscription_id}'
            , 'PUT', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='bool', auth_settings=auth_settings, async_req=
            local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def update_virt_realm_remote_access_config(self, id,
        remote_access_config, **kwargs):
        """Update Remote Access  # noqa: E501

        Updates the Remote Access configuration for a single Virtualization Realm by the given ID.<br> <br> Note: remoteAccessIpAddress cannot be updated if the Virtualization Realm's Remote Access is currently enabled.  # 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_virt_realm_remote_access_config(id, remote_access_config, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param RemoteAccessConfig remote_access_config: The updated remote access configuration (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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.update_virt_realm_remote_access_config_with_http_info(id,
            remote_access_config, **kwargs)

    def update_virt_realm_remote_access_config_with_http_info(self, id,
        remote_access_config, **kwargs):
        """Update Remote Access  # noqa: E501

        Updates the Remote Access configuration for a single Virtualization Realm by the given ID.<br> <br> Note: remoteAccessIpAddress cannot be updated if the Virtualization Realm's Remote Access is currently enabled.  # 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_virt_realm_remote_access_config_with_http_info(id, remote_access_config, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param RemoteAccessConfig remote_access_config: The updated remote access configuration (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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'remote_access_config']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_virt_realm_remote_access_config"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `update_virt_realm_remote_access_config`'
                )
        if self.api_client.client_side_validation and (
            'remote_access_config' not in local_var_params or 
            local_var_params['remote_access_config'] is None):
            raise ApiValueError(
                'Missing the required parameter `remote_access_config` when calling `update_virt_realm_remote_access_config`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        if 'remote_access_config' in local_var_params:
            body_params = local_var_params['remote_access_config']
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        header_params['Content-Type'
            ] = self.api_client.select_header_content_type([
            'application/json', 'application/xml'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/remoteaccess', 'PUT',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'bool', auth_settings=auth_settings, async_req=local_var_params
            .get('async_req'), _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)
    <mask token>

    def update_virtualization_realm_with_http_info(self, id, **kwargs):
        """Update Virtualization Realm  # noqa: E501

        Updates the content of a single Virtualization Realm with the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.update_virtualization_realm_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param InputVRAdminVirtualizationRealm input_vr_admin_virtualization_realm: The updated Virtualization Realm data
        :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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'input_vr_admin_virtualization_realm']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_virtualization_realm"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `update_virtualization_realm`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        if 'input_vr_admin_virtualization_realm' in local_var_params:
            body_params = local_var_params[
                'input_vr_admin_virtualization_realm']
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        header_params['Content-Type'
            ] = self.api_client.select_header_content_type([
            'application/json', 'application/xml'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api('/api/virtualizationrealms/{id}',
            'PUT', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='bool', auth_settings=auth_settings, async_req=
            local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def update_virtualization_realm_reachability(self, id, **kwargs):
        """update_virtualization_realm_reachability  # 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_virtualization_realm_reachability(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.update_virtualization_realm_reachability_with_http_info(id,
            **kwargs)

    def update_virtualization_realm_reachability_with_http_info(self, id,
        **kwargs):
        """update_virtualization_realm_reachability  # 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_virtualization_realm_reachability_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_virtualization_realm_reachability"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `update_virtualization_realm_reachability`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json', 'application/xml'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/updatereachability', 'PUT',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'bool', auth_settings=auth_settings, async_req=local_var_params
            .get('async_req'), _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

<mask token>


class VirtualizationRealmsApi(object):
    """NOTE: This class is auto-generated. 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 add_network(self, id, abstract_add_network_cloud_space_request, **
        kwargs):
        """Allocate Network  # noqa: E501

        Adds a Network to the specified Virtualization Realm.<br> <br> Since this call results in the construction of a new, back-end Network it has financial implications and should not be used if the user is not prepared to incur the expense of construction and existence of the newly created Network.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.add_network(id, abstract_add_network_cloud_space_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param AbstractAddNetworkCloudSpaceRequest abstract_add_network_cloud_space_request: The network allocation information (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: MinimalVirtualizationRealm
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.add_network_with_http_info(id,
            abstract_add_network_cloud_space_request, **kwargs)

    def add_network_with_http_info(self, id,
        abstract_add_network_cloud_space_request, **kwargs):
        """Allocate Network  # noqa: E501

        Adds a Network to the specified Virtualization Realm.<br> <br> Since this call results in the construction of a new, back-end Network it has financial implications and should not be used if the user is not prepared to incur the expense of construction and existence of the newly created Network.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.add_network_with_http_info(id, abstract_add_network_cloud_space_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param AbstractAddNetworkCloudSpaceRequest abstract_add_network_cloud_space_request: The network allocation information (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(MinimalVirtualizationRealm, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'abstract_add_network_cloud_space_request']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 add_network"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `add_network`'
                )
        if self.api_client.client_side_validation and (
            'abstract_add_network_cloud_space_request' not in
            local_var_params or local_var_params[
            'abstract_add_network_cloud_space_request'] is None):
            raise ApiValueError(
                'Missing the required parameter `abstract_add_network_cloud_space_request` when calling `add_network`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        if 'abstract_add_network_cloud_space_request' in local_var_params:
            body_params = local_var_params[
                'abstract_add_network_cloud_space_request']
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        header_params['Content-Type'
            ] = self.api_client.select_header_content_type([
            'application/json', 'application/xml'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/networks', 'POST', path_params,
            query_params, header_params, body=body_params, post_params=
            form_params, files=local_var_files, response_type=
            'MinimalVirtualizationRealm', auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def add_project(self, id, project_id, **kwargs):
        """Assign Project  # noqa: E501

        Provides members of the Project with access to the specified Virtualization Realm  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.add_project(id, project_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param str project_id: ID of project to assign (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: int
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.add_project_with_http_info(id, project_id, **kwargs)

    def add_project_with_http_info(self, id, project_id, **kwargs):
        """Assign Project  # noqa: E501

        Provides members of the Project with access to the specified Virtualization Realm  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.add_project_with_http_info(id, project_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param str project_id: ID of project to assign (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(int, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'project_id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 add_project"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `add_project`'
                )
        if self.api_client.client_side_validation and ('project_id' not in
            local_var_params or local_var_params['project_id'] is None):
            raise ApiValueError(
                'Missing the required parameter `project_id` when calling `add_project`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        if 'project_id' in local_var_params and local_var_params['project_id'
            ] is not None:
            query_params.append(('projectId', local_var_params['project_id']))
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/projects', 'PUT', path_params,
            query_params, header_params, body=body_params, post_params=
            form_params, files=local_var_files, response_type='int',
            auth_settings=auth_settings, async_req=local_var_params.get(
            'async_req'), _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def create_template_subsciption(self, id, registration_id, **kwargs):
        """Create Template Subscription  # noqa: E501

        Creates a Template Subscription in the specified Virtualization Realm.  # 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_template_subsciption(id, registration_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (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: FullTemplateSubscription
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.create_template_subsciption_with_http_info(id,
            registration_id, **kwargs)

    def create_template_subsciption_with_http_info(self, id,
        registration_id, **kwargs):
        """Create Template Subscription  # noqa: E501

        Creates a Template Subscription in the specified Virtualization Realm.  # 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_template_subsciption_with_http_info(id, registration_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (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(FullTemplateSubscription, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'registration_id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_template_subsciption"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `create_template_subsciption`'
                )
        if self.api_client.client_side_validation and ('registration_id' not in
            local_var_params or local_var_params['registration_id'] is None):
            raise ApiValueError(
                'Missing the required parameter `registration_id` when calling `create_template_subsciption`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        if 'registration_id' in local_var_params and local_var_params[
            'registration_id'] is not None:
            query_params.append(('registration_id', local_var_params[
                'registration_id']))
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/subscriptions',
            'POST', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='FullTemplateSubscription', auth_settings=
            auth_settings, async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def delete_network(self, id, network_id, **kwargs):
        """Delete Network  # noqa: E501

        Removes an existing Network from the specified Virtualization Realm.  # 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_network(id, network_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param int network_id: ID of network (required)
        :param bool deallocate: Attempt to delete all back-end resources
        :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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.delete_network_with_http_info(id, network_id, **kwargs)

    def delete_network_with_http_info(self, id, network_id, **kwargs):
        """Delete Network  # noqa: E501

        Removes an existing Network from the specified Virtualization Realm.  # 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_network_with_http_info(id, network_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param int network_id: ID of network (required)
        :param bool deallocate: Attempt to delete all back-end resources
        :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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'network_id', 'deallocate']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_network"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `delete_network`'
                )
        if self.api_client.client_side_validation and ('network_id' not in
            local_var_params or local_var_params['network_id'] is None):
            raise ApiValueError(
                'Missing the required parameter `network_id` when calling `delete_network`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        if 'network_id' in local_var_params:
            path_params['networkId'] = local_var_params['network_id']
        query_params = []
        if 'deallocate' in local_var_params and local_var_params['deallocate'
            ] is not None:
            query_params.append(('deallocate', local_var_params['deallocate']))
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/networks/{networkId}', 'DELETE',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'bool', auth_settings=auth_settings, async_req=local_var_params
            .get('async_req'), _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def delete_template_subscription(self, id, subscription_id, **kwargs):
        """Delete Template Subscription  # noqa: E501

        Removes an existing Template Subscription from the specified Virtualization Realm.  # 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_template_subscription(id, subscription_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int subscription_id: ID of template subscription (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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.delete_template_subscription_with_http_info(id,
            subscription_id, **kwargs)

    def delete_template_subscription_with_http_info(self, id,
        subscription_id, **kwargs):
        """Delete Template Subscription  # noqa: E501

        Removes an existing Template Subscription from the specified Virtualization Realm.  # 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_template_subscription_with_http_info(id, subscription_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int subscription_id: ID of template subscription (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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'subscription_id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_template_subscription"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `delete_template_subscription`'
                )
        if self.api_client.client_side_validation and ('subscription_id' not in
            local_var_params or local_var_params['subscription_id'] is None):
            raise ApiValueError(
                'Missing the required parameter `subscription_id` when calling `delete_template_subscription`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        if 'subscription_id' in local_var_params:
            path_params['subscription_id'] = local_var_params['subscription_id'
                ]
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/subscriptions/{subscription_id}'
            , 'DELETE', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='bool', auth_settings=auth_settings, async_req=
            local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def disable_virt_realm_remote_access(self, id, **kwargs):
        """Disable Remote Access  # noqa: E501

        Disables Remote Access for a single Virtualization Realm by the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.disable_virt_realm_remote_access(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.disable_virt_realm_remote_access_with_http_info(id, **
            kwargs)

    def disable_virt_realm_remote_access_with_http_info(self, id, **kwargs):
        """Disable Remote Access  # noqa: E501

        Disables Remote Access for a single Virtualization Realm by the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.disable_virt_realm_remote_access_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 disable_virt_realm_remote_access"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `disable_virt_realm_remote_access`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/remoteaccess', 'DELETE',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'bool', auth_settings=auth_settings, async_req=local_var_params
            .get('async_req'), _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def enable_maintence_mode1(self, id, **kwargs):
        """Update Maintenance Mode  # noqa: E501

        Updates the maintenance status for a single Virtualization Realm by the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.enable_maintence_mode1(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param bool enable: Enable or disable maintenance mode
        :param MaintenanceModeRequest maintenance_mode_request: The maintenance mode request, when enabling maintenance mode
        :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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.enable_maintence_mode1_with_http_info(id, **kwargs)

    def enable_maintence_mode1_with_http_info(self, id, **kwargs):
        """Update Maintenance Mode  # noqa: E501

        Updates the maintenance status for a single Virtualization Realm by the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.enable_maintence_mode1_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param bool enable: Enable or disable maintenance mode
        :param MaintenanceModeRequest maintenance_mode_request: The maintenance mode request, when enabling maintenance mode
        :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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'enable', 'maintenance_mode_request']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 enable_maintence_mode1"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `enable_maintence_mode1`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        if 'enable' in local_var_params and local_var_params['enable'
            ] is not None:
            query_params.append(('enable', local_var_params['enable']))
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        if 'maintenance_mode_request' in local_var_params:
            body_params = local_var_params['maintenance_mode_request']
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        header_params['Content-Type'
            ] = self.api_client.select_header_content_type([
            'application/json', 'application/xml'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/maintenance', 'PUT',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'bool', auth_settings=auth_settings, async_req=local_var_params
            .get('async_req'), _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def enable_virt_realm_remote_access(self, id, **kwargs):
        """Enable Remote Access  # noqa: E501

        Enables Remote Access for a single Virtualization Realm by the given ID.<br> <br> To do so, Remote Access must be configured for the Virtualization Realm.<br> <br> If no instanceType is provided, the Instance Type will first attempt to use the value from the Virtualization Realm's Remote Access config.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.enable_virt_realm_remote_access(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param str instance_type: Remote access server instance type
        :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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.enable_virt_realm_remote_access_with_http_info(id, **kwargs
            )

    def enable_virt_realm_remote_access_with_http_info(self, id, **kwargs):
        """Enable Remote Access  # noqa: E501

        Enables Remote Access for a single Virtualization Realm by the given ID.<br> <br> To do so, Remote Access must be configured for the Virtualization Realm.<br> <br> If no instanceType is provided, the Instance Type will first attempt to use the value from the Virtualization Realm's Remote Access config.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.enable_virt_realm_remote_access_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param str instance_type: Remote access server instance type
        :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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'instance_type']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 enable_virt_realm_remote_access"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `enable_virt_realm_remote_access`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        if 'instance_type' in local_var_params and local_var_params[
            'instance_type'] is not None:
            query_params.append(('instanceType', local_var_params[
                'instance_type']))
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/remoteaccess', 'POST',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'bool', auth_settings=auth_settings, async_req=local_var_params
            .get('async_req'), _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def get_deployment_runs_in_virtualization_realm(self, id, search_type,
        **kwargs):
        """List Deployment Runs  # noqa: E501

        Returns a collection of the Deployment Runs launched into the specified Virtualization Realm.  # 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_deployment_runs_in_virtualization_realm(id, search_type, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param str search_type: Deployment run status type (required)
        :param int maxresults: Maximum number of results to return
        :param int page: Requested page number
        :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[MinimalDeploymentRun]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_deployment_runs_in_virtualization_realm_with_http_info(
            id, search_type, **kwargs)

    def get_deployment_runs_in_virtualization_realm_with_http_info(self, id,
        search_type, **kwargs):
        """List Deployment Runs  # noqa: E501

        Returns a collection of the Deployment Runs launched into the specified Virtualization Realm.  # 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_deployment_runs_in_virtualization_realm_with_http_info(id, search_type, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param str search_type: Deployment run status type (required)
        :param int maxresults: Maximum number of results to return
        :param int page: Requested page number
        :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[MinimalDeploymentRun], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'search_type', 'maxresults', 'page']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_deployment_runs_in_virtualization_realm"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `get_deployment_runs_in_virtualization_realm`'
                )
        if self.api_client.client_side_validation and ('search_type' not in
            local_var_params or local_var_params['search_type'] is None):
            raise ApiValueError(
                'Missing the required parameter `search_type` when calling `get_deployment_runs_in_virtualization_realm`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        if 'search_type' in local_var_params and local_var_params['search_type'
            ] is not None:
            query_params.append(('search_type', local_var_params[
                'search_type']))
        if 'maxresults' in local_var_params and local_var_params['maxresults'
            ] is not None:
            query_params.append(('maxresults', local_var_params['maxresults']))
        if 'page' in local_var_params and local_var_params['page'] is not None:
            query_params.append(('page', local_var_params['page']))
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/deploymentruns', 'GET',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'list[MinimalDeploymentRun]', auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def get_host_configuration_metrics1(self, id, start, end, **kwargs):
        """Retrieve Metrics  # noqa: E501

        Returns metric data for Deployment Runs launched into the specified Virtualization Realm.  # 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_host_configuration_metrics1(id, start, end, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param int start: Interval start time, specified in seconds since epoch (required)
        :param int end: Interval end time, specified in seconds since epoch (required)
        :param int interval: Number of intervals
        :param str interval_unit: Interval unit
        :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_host_configuration_metrics1_with_http_info(id,
            start, end, **kwargs)

    def get_host_configuration_metrics1_with_http_info(self, id, start, end,
        **kwargs):
        """Retrieve Metrics  # noqa: E501

        Returns metric data for Deployment Runs launched into the specified Virtualization Realm.  # 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_host_configuration_metrics1_with_http_info(id, start, end, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param int start: Interval start time, specified in seconds since epoch (required)
        :param int end: Interval end time, specified in seconds since epoch (required)
        :param int interval: Number of intervals
        :param str interval_unit: Interval unit
        :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 = ['id', 'start', 'end', 'interval', 'interval_unit']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_host_configuration_metrics1"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `get_host_configuration_metrics1`'
                )
        if self.api_client.client_side_validation and ('start' not in
            local_var_params or local_var_params['start'] is None):
            raise ApiValueError(
                'Missing the required parameter `start` when calling `get_host_configuration_metrics1`'
                )
        if self.api_client.client_side_validation and ('end' not in
            local_var_params or local_var_params['end'] is None):
            raise ApiValueError(
                'Missing the required parameter `end` when calling `get_host_configuration_metrics1`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        if 'start' in local_var_params and local_var_params['start'
            ] is not None:
            query_params.append(('start', local_var_params['start']))
        if 'end' in local_var_params and local_var_params['end'] is not None:
            query_params.append(('end', local_var_params['end']))
        if 'interval' in local_var_params and local_var_params['interval'
            ] is not None:
            query_params.append(('interval', local_var_params['interval']))
        if 'interval_unit' in local_var_params and local_var_params[
            'interval_unit'] is not None:
            query_params.append(('intervalUnit', local_var_params[
                'interval_unit']))
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/metrics/hostconfiguration',
            'GET', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='str', auth_settings=auth_settings, async_req=
            local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_network(self, id, network_id, **kwargs):
        """Retrieve Network  # noqa: E501

        Returns a single Network in the specified Virtualization Realm.  # 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_network(id, network_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param int network_id: ID of network (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: Network
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_network_with_http_info(id, network_id, **kwargs)

    def get_network_with_http_info(self, id, network_id, **kwargs):
        """Retrieve Network  # noqa: E501

        Returns a single Network in the specified Virtualization Realm.  # 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_network_with_http_info(id, network_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param int network_id: ID of network (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(Network, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'network_id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_network"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `get_network`'
                )
        if self.api_client.client_side_validation and ('network_id' not in
            local_var_params or local_var_params['network_id'] is None):
            raise ApiValueError(
                'Missing the required parameter `network_id` when calling `get_network`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        if 'network_id' in local_var_params:
            path_params['networkId'] = local_var_params['network_id']
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/networks/{networkId}', 'GET',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'Network', auth_settings=auth_settings, async_req=
            local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_networks(self, id, **kwargs):
        """List Networks  # noqa: E501

        Returns a collection of the Networks in the specified Virtualization Realm.  # 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_networks(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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[MinimalNetwork]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_networks_with_http_info(id, **kwargs)

    def get_networks_with_http_info(self, id, **kwargs):
        """List Networks  # noqa: E501

        Returns a collection of the Networks in the specified Virtualization Realm.  # 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_networks_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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[MinimalNetwork], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_networks"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `get_networks`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/networks', 'GET', path_params,
            query_params, header_params, body=body_params, post_params=
            form_params, files=local_var_files, response_type=
            'list[MinimalNetwork]', auth_settings=auth_settings, async_req=
            local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_template_subscription(self, id, subscription_id, **kwargs):
        """Retrieve Template Subscription  # noqa: E501

        Returns a single Template Subscription in the specified Virtualization Realm.  # 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_template_subscription(id, subscription_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int subscription_id: ID of template subscription (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: FullTemplateSubscription
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_template_subscription_with_http_info(id,
            subscription_id, **kwargs)

    def get_template_subscription_with_http_info(self, id, subscription_id,
        **kwargs):
        """Retrieve Template Subscription  # noqa: E501

        Returns a single Template Subscription in the specified Virtualization Realm.  # 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_template_subscription_with_http_info(id, subscription_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int subscription_id: ID of template subscription (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(FullTemplateSubscription, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'subscription_id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_template_subscription"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `get_template_subscription`'
                )
        if self.api_client.client_side_validation and ('subscription_id' not in
            local_var_params or local_var_params['subscription_id'] is None):
            raise ApiValueError(
                'Missing the required parameter `subscription_id` when calling `get_template_subscription`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        if 'subscription_id' in local_var_params:
            path_params['subscription_id'] = local_var_params['subscription_id'
                ]
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/subscriptions/{subscription_id}'
            , 'GET', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='FullTemplateSubscription', auth_settings=
            auth_settings, async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def get_templates_in_virtualization_realm(self, id, **kwargs):
        """List Templates  # noqa: E501

        Returns a collection of the Templates in the specified Virtualization Realm.  # 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_templates_in_virtualization_realm(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param bool include_registrations: Include templates registered to the virtualization realm
        :param bool include_subscriptions: Include templates subscribed to by the virtualization realm
        :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[MinimalCons3rtTemplateData]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_templates_in_virtualization_realm_with_http_info(id,
            **kwargs)

    def get_templates_in_virtualization_realm_with_http_info(self, id, **kwargs
        ):
        """List Templates  # noqa: E501

        Returns a collection of the Templates in the specified Virtualization Realm.  # 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_templates_in_virtualization_realm_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param bool include_registrations: Include templates registered to the virtualization realm
        :param bool include_subscriptions: Include templates subscribed to by the virtualization realm
        :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[MinimalCons3rtTemplateData], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'include_registrations', 'include_subscriptions']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_templates_in_virtualization_realm"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `get_templates_in_virtualization_realm`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        if 'include_registrations' in local_var_params and local_var_params[
            'include_registrations'] is not None:
            query_params.append(('include_registrations', local_var_params[
                'include_registrations']))
        if 'include_subscriptions' in local_var_params and local_var_params[
            'include_subscriptions'] is not None:
            query_params.append(('include_subscriptions', local_var_params[
                'include_subscriptions']))
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates', 'GET', path_params,
            query_params, header_params, body=body_params, post_params=
            form_params, files=local_var_files, response_type=
            'list[MinimalCons3rtTemplateData]', auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def get_unregistered_networks(self, id, **kwargs):
        """List Unregistered Networks  # noqa: E501

        Returns a collection of the unregistered, back-end Networks in the specified Virtualization Realm.  # 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_unregistered_networks(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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[Subnet]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_unregistered_networks_with_http_info(id, **kwargs)

    def get_unregistered_networks_with_http_info(self, id, **kwargs):
        """List Unregistered Networks  # noqa: E501

        Returns a collection of the unregistered, back-end Networks in the specified Virtualization Realm.  # 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_unregistered_networks_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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[Subnet], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_unregistered_networks"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `get_unregistered_networks`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/networks/unregistered', 'GET',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'list[Subnet]', auth_settings=auth_settings, async_req=
            local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_virtual_machine_count_metrics1(self, id, start, end, **kwargs):
        """Retrieve Virtual Machine Metrics  # noqa: E501

        Returns metric data for Virtual Machines launched into the specified Virtualization Realm.  # 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_virtual_machine_count_metrics1(id, start, end, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param int start: Interval start time, specified in seconds since epoch (required)
        :param int end: Interval end time, specified in seconds since epoch (required)
        :param int interval: Number of intervals
        :param str interval_unit: Interval unit
        :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_virtual_machine_count_metrics1_with_http_info(id,
            start, end, **kwargs)

    def get_virtual_machine_count_metrics1_with_http_info(self, id, start,
        end, **kwargs):
        """Retrieve Virtual Machine Metrics  # noqa: E501

        Returns metric data for Virtual Machines launched into the specified Virtualization Realm.  # 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_virtual_machine_count_metrics1_with_http_info(id, start, end, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param int start: Interval start time, specified in seconds since epoch (required)
        :param int end: Interval end time, specified in seconds since epoch (required)
        :param int interval: Number of intervals
        :param str interval_unit: Interval unit
        :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 = ['id', 'start', 'end', 'interval', 'interval_unit']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_virtual_machine_count_metrics1"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `get_virtual_machine_count_metrics1`'
                )
        if self.api_client.client_side_validation and ('start' not in
            local_var_params or local_var_params['start'] is None):
            raise ApiValueError(
                'Missing the required parameter `start` when calling `get_virtual_machine_count_metrics1`'
                )
        if self.api_client.client_side_validation and ('end' not in
            local_var_params or local_var_params['end'] is None):
            raise ApiValueError(
                'Missing the required parameter `end` when calling `get_virtual_machine_count_metrics1`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        if 'start' in local_var_params and local_var_params['start'
            ] is not None:
            query_params.append(('start', local_var_params['start']))
        if 'end' in local_var_params and local_var_params['end'] is not None:
            query_params.append(('end', local_var_params['end']))
        if 'interval' in local_var_params and local_var_params['interval'
            ] is not None:
            query_params.append(('interval', local_var_params['interval']))
        if 'interval_unit' in local_var_params and local_var_params[
            'interval_unit'] is not None:
            query_params.append(('intervalUnit', local_var_params[
                'interval_unit']))
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/metrics/virtualmachinecount',
            'GET', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='str', auth_settings=auth_settings, async_req=
            local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def get_virtualization_realm(self, id, **kwargs):
        """Retrieve Virtualization Realm  # noqa: E501

        Returns a single Virtualization Realm by the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_virtualization_realm(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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: FullVirtualizationRealm
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_virtualization_realm_with_http_info(id, **kwargs)

    def get_virtualization_realm_with_http_info(self, id, **kwargs):
        """Retrieve Virtualization Realm  # noqa: E501

        Returns a single Virtualization Realm by the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_virtualization_realm_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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(FullVirtualizationRealm, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_virtualization_realm"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `get_virtualization_realm`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api('/api/virtualizationrealms/{id}',
            'GET', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='FullVirtualizationRealm', auth_settings=
            auth_settings, async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def get_virtualization_realm_resources(self, id, **kwargs):
        """Retrieve Virtualization Realm Resources  # noqa: E501

        Returns the back-end resources for a single Virtualization Realm by the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_virtualization_realm_resources(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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: AbstractCloudResources
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_virtualization_realm_resources_with_http_info(id,
            **kwargs)

    def get_virtualization_realm_resources_with_http_info(self, id, **kwargs):
        """Retrieve Virtualization Realm Resources  # noqa: E501

        Returns the back-end resources for a single Virtualization Realm by the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_virtualization_realm_resources_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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(AbstractCloudResources, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_virtualization_realm_resources"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `get_virtualization_realm_resources`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/resources', 'GET', path_params,
            query_params, header_params, body=body_params, post_params=
            form_params, files=local_var_files, response_type=
            'AbstractCloudResources', auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def get_virtualization_realms(self, **kwargs):
        """List Virtualization Realms  # noqa: E501

        Returns a collection of the Virtualization Realms that the user manages.  # 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_virtualization_realms(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int maxresults: Maximum number of results to return
        :param int page: Requested page number
        :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[MinimalVirtualizationRealm]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_virtualization_realms_with_http_info(**kwargs)

    def get_virtualization_realms_with_http_info(self, **kwargs):
        """List Virtualization Realms  # noqa: E501

        Returns a collection of the Virtualization Realms that the user manages.  # 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_virtualization_realms_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int maxresults: Maximum number of results to return
        :param int page: Requested page number
        :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[MinimalVirtualizationRealm], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['maxresults', 'page']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_virtualization_realms"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        collection_formats = {}
        path_params = {}
        query_params = []
        if 'maxresults' in local_var_params and local_var_params['maxresults'
            ] is not None:
            query_params.append(('maxresults', local_var_params['maxresults']))
        if 'page' in local_var_params and local_var_params['page'] is not None:
            query_params.append(('page', local_var_params['page']))
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api('/api/virtualizationrealms', 'GET',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'list[MinimalVirtualizationRealm]', auth_settings=auth_settings,
            async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def invalidate_template_cache_in_virtualization_realm(self, id, **kwargs):
        """Refresh Template Cache  # noqa: E501

        Forces the back-end Template data to be re-read in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.invalidate_template_cache_in_virtualization_realm(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return (self.
            invalidate_template_cache_in_virtualization_realm_with_http_info
            (id, **kwargs))

    def invalidate_template_cache_in_virtualization_realm_with_http_info(self,
        id, **kwargs):
        """Refresh Template Cache  # noqa: E501

        Forces the back-end Template data to be re-read in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.invalidate_template_cache_in_virtualization_realm_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 invalidate_template_cache_in_virtualization_realm"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `invalidate_template_cache_in_virtualization_realm`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/registrations', 'PUT',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'bool', auth_settings=auth_settings, async_req=local_var_params
            .get('async_req'), _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def list_pending_template_subscriptions(self, id, **kwargs):
        """List Pending Subscriptions  # noqa: E501

        Returns a collection of the pending Template Subscriptions in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_pending_template_subscriptions(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (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[FullTemplateRegistrationForSubscription]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.list_pending_template_subscriptions_with_http_info(id,
            **kwargs)

    def list_pending_template_subscriptions_with_http_info(self, id, **kwargs):
        """List Pending Subscriptions  # noqa: E501

        Returns a collection of the pending Template Subscriptions in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_pending_template_subscriptions_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (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[FullTemplateRegistrationForSubscription], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 list_pending_template_subscriptions"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `list_pending_template_subscriptions`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/subscriptions/pending',
            'GET', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='list[FullTemplateRegistrationForSubscription]',
            auth_settings=auth_settings, async_req=local_var_params.get(
            'async_req'), _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def list_projects(self, id, **kwargs):
        """List Projects  # noqa: E501

        Returns a collection of the Projects allowed to access to the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_projects(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param int maxresults: Maximum number of results to return
        :param int page: Requested page number
        :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[MinimalProject]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.list_projects_with_http_info(id, **kwargs)

    def list_projects_with_http_info(self, id, **kwargs):
        """List Projects  # noqa: E501

        Returns a collection of the Projects allowed to access to the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_projects_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param int maxresults: Maximum number of results to return
        :param int page: Requested page number
        :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[MinimalProject], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'maxresults', 'page']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 list_projects"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `list_projects`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        if 'maxresults' in local_var_params and local_var_params['maxresults'
            ] is not None:
            query_params.append(('maxresults', local_var_params['maxresults']))
        if 'page' in local_var_params and local_var_params['page'] is not None:
            query_params.append(('page', local_var_params['page']))
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/projects', 'GET', path_params,
            query_params, header_params, body=body_params, post_params=
            form_params, files=local_var_files, response_type=
            'list[MinimalProject]', auth_settings=auth_settings, async_req=
            local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def list_template_registrations(self, id, **kwargs):
        """List Template Registrations  # noqa: E501

        Returns a collection of the Template Registrations in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_template_registrations(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (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[MinimalTemplateRegistration]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.list_template_registrations_with_http_info(id, **kwargs)

    def list_template_registrations_with_http_info(self, id, **kwargs):
        """List Template Registrations  # noqa: E501

        Returns a collection of the Template Registrations in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_template_registrations_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (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[MinimalTemplateRegistration], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 list_template_registrations"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `list_template_registrations`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/registrations', 'GET',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'list[MinimalTemplateRegistration]', auth_settings=
            auth_settings, async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def list_template_subscriptions(self, id, **kwargs):
        """List Template Subscriptions  # noqa: E501

        Returns a collection of the Template Subscriptions in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_template_subscriptions(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (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[MinimalTemplateSubscription]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.list_template_subscriptions_with_http_info(id, **kwargs)

    def list_template_subscriptions_with_http_info(self, id, **kwargs):
        """List Template Subscriptions  # noqa: E501

        Returns a collection of the Template Subscriptions in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_template_subscriptions_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (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[MinimalTemplateSubscription], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 list_template_subscriptions"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `list_template_subscriptions`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/subscriptions', 'GET',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'list[MinimalTemplateSubscription]', auth_settings=
            auth_settings, async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def list_unregistered_templates(self, id, **kwargs):
        """List Unregistered Templates  # noqa: E501

        Returns a collection of the unregistered, back-end Templates in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_unregistered_templates(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (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[Cons3rtTemplateTagData]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.list_unregistered_templates_with_http_info(id, **kwargs)

    def list_unregistered_templates_with_http_info(self, id, **kwargs):
        """List Unregistered Templates  # noqa: E501

        Returns a collection of the unregistered, back-end Templates in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_unregistered_templates_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (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[Cons3rtTemplateTagData], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 list_unregistered_templates"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `list_unregistered_templates`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/registrations/pending',
            'GET', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='list[Cons3rtTemplateTagData]', auth_settings=
            auth_settings, async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def register_network(self, id, network_identifier, **kwargs):
        """Register Network  # noqa: E501

        Adds an existing, back-end Network the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.register_network(id, network_identifier, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param str network_identifier: Back-end network identifier (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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.register_network_with_http_info(id, network_identifier,
            **kwargs)

    def register_network_with_http_info(self, id, network_identifier, **kwargs
        ):
        """Register Network  # noqa: E501

        Adds an existing, back-end Network the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.register_network_with_http_info(id, network_identifier, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param str network_identifier: Back-end network identifier (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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'network_identifier']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 register_network"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `register_network`'
                )
        if self.api_client.client_side_validation and ('network_identifier'
             not in local_var_params or local_var_params[
            'network_identifier'] is None):
            raise ApiValueError(
                'Missing the required parameter `network_identifier` when calling `register_network`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        if 'network_identifier' in local_var_params:
            path_params['networkIdentifier'] = local_var_params[
                'network_identifier']
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/networks/{networkIdentifier}',
            'PUT', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='bool', auth_settings=auth_settings, async_req=
            local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def register_template(self, id, **kwargs):
        """Register Template  # noqa: E501

        Adds an existing back-end Template to the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.register_template(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param InputRegisterTemplateObject input_register_template_object: The template registration data
        :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: FullTemplateRegistration
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.register_template_with_http_info(id, **kwargs)

    def register_template_with_http_info(self, id, **kwargs):
        """Register Template  # noqa: E501

        Adds an existing back-end Template to the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.register_template_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param InputRegisterTemplateObject input_register_template_object: The template registration data
        :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(FullTemplateRegistration, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'input_register_template_object']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 register_template"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `register_template`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        if 'input_register_template_object' in local_var_params:
            body_params = local_var_params['input_register_template_object']
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        header_params['Content-Type'
            ] = self.api_client.select_header_content_type([
            'application/json', 'application/xml'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/registrations',
            'POST', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='FullTemplateRegistration', auth_settings=
            auth_settings, async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def remove_project(self, id, project_id, **kwargs):
        """Unassign Project  # noqa: E501

        Revokes Project member access to the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.remove_project(id, project_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param str project_id: ID of project to unassign (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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.remove_project_with_http_info(id, project_id, **kwargs)

    def remove_project_with_http_info(self, id, project_id, **kwargs):
        """Unassign Project  # noqa: E501

        Revokes Project member access to the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.remove_project_with_http_info(id, project_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param str project_id: ID of project to unassign (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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'project_id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 remove_project"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `remove_project`'
                )
        if self.api_client.client_side_validation and ('project_id' not in
            local_var_params or local_var_params['project_id'] is None):
            raise ApiValueError(
                'Missing the required parameter `project_id` when calling `remove_project`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        if 'project_id' in local_var_params and local_var_params['project_id'
            ] is not None:
            query_params.append(('projectId', local_var_params['project_id']))
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/projects', 'DELETE',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'bool', auth_settings=auth_settings, async_req=local_var_params
            .get('async_req'), _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def retrieve_template_registration(self, id, registration_id, **kwargs):
        """Retrieve Template Registration  # noqa: E501

        Returns a single Template Registration in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_template_registration(id, registration_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (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: FullTemplateRegistration
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.retrieve_template_registration_with_http_info(id,
            registration_id, **kwargs)

    def retrieve_template_registration_with_http_info(self, id,
        registration_id, **kwargs):
        """Retrieve Template Registration  # noqa: E501

        Returns a single Template Registration in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_template_registration_with_http_info(id, registration_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (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(FullTemplateRegistration, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'registration_id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 retrieve_template_registration"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `retrieve_template_registration`'
                )
        if self.api_client.client_side_validation and ('registration_id' not in
            local_var_params or local_var_params['registration_id'] is None):
            raise ApiValueError(
                'Missing the required parameter `registration_id` when calling `retrieve_template_registration`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        if 'registration_id' in local_var_params:
            path_params['registration_id'] = local_var_params['registration_id'
                ]
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/registrations/{registration_id}'
            , 'GET', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='FullTemplateRegistration', auth_settings=
            auth_settings, async_req=local_var_params.get('async_req'),
            _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def set_virtualization_realm_active(self, id, activate, **kwargs):
        """Update State  # noqa: E501

        Updates the active State for a single Virtualization Realm by the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.set_virtualization_realm_active(id, activate, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param bool activate: Activate or deactivate virtualization realm (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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.set_virtualization_realm_active_with_http_info(id,
            activate, **kwargs)

    def set_virtualization_realm_active_with_http_info(self, id, activate,
        **kwargs):
        """Update State  # noqa: E501

        Updates the active State for a single Virtualization Realm by the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.set_virtualization_realm_active_with_http_info(id, activate, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param bool activate: Activate or deactivate virtualization realm (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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'activate']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 set_virtualization_realm_active"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `set_virtualization_realm_active`'
                )
        if self.api_client.client_side_validation and ('activate' not in
            local_var_params or local_var_params['activate'] is None):
            raise ApiValueError(
                'Missing the required parameter `activate` when calling `set_virtualization_realm_active`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        if 'activate' in local_var_params and local_var_params['activate'
            ] is not None:
            query_params.append(('activate', local_var_params['activate']))
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/activate', 'PUT', path_params,
            query_params, header_params, body=body_params, post_params=
            form_params, files=local_var_files, response_type='bool',
            auth_settings=auth_settings, async_req=local_var_params.get(
            'async_req'), _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def share_template_registration(self, id, registration_id,
        target_realm_ids, **kwargs):
        """Share Template  # noqa: E501

        Shares an existing Template Registration in the specified Virtualization Realm to the provided external Virtualization Realm(s).  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.share_template_registration(id, registration_id, target_realm_ids, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (required)
        :param list[int] target_realm_ids: ID(s) of external virtualization realms to share template registration with (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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.share_template_registration_with_http_info(id,
            registration_id, target_realm_ids, **kwargs)

    def share_template_registration_with_http_info(self, id,
        registration_id, target_realm_ids, **kwargs):
        """Share Template  # noqa: E501

        Shares an existing Template Registration in the specified Virtualization Realm to the provided external Virtualization Realm(s).  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.share_template_registration_with_http_info(id, registration_id, target_realm_ids, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (required)
        :param list[int] target_realm_ids: ID(s) of external virtualization realms to share template registration with (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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'registration_id', 'target_realm_ids']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 share_template_registration"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `share_template_registration`'
                )
        if self.api_client.client_side_validation and ('registration_id' not in
            local_var_params or local_var_params['registration_id'] is None):
            raise ApiValueError(
                'Missing the required parameter `registration_id` when calling `share_template_registration`'
                )
        if self.api_client.client_side_validation and ('target_realm_ids'
             not in local_var_params or local_var_params['target_realm_ids'
            ] is None):
            raise ApiValueError(
                'Missing the required parameter `target_realm_ids` when calling `share_template_registration`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        if 'registration_id' in local_var_params:
            path_params['registration_id'] = local_var_params['registration_id'
                ]
        query_params = []
        if 'target_realm_ids' in local_var_params and local_var_params[
            'target_realm_ids'] is not None:
            query_params.append(('target_realm_ids', local_var_params[
                'target_realm_ids']))
            collection_formats['target_realm_ids'] = 'multi'
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/registrations/{registration_id}/share'
            , 'POST', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='bool', auth_settings=auth_settings, async_req=
            local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def unregister_template(self, id, registration_id,
        input_unregister_template_object, **kwargs):
        """Delete Template Registration  # noqa: E501

        Removes an existing Template Registration from the specified Virtualization Realm.<br> <br> Note: Unregistering a Template will remove all subscriptions to the Template from other Virtualization Realms.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.unregister_template(id, registration_id, input_unregister_template_object, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (required)
        :param InputUnregisterTemplateObject input_unregister_template_object: The deletion settings (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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.unregister_template_with_http_info(id, registration_id,
            input_unregister_template_object, **kwargs)

    def unregister_template_with_http_info(self, id, registration_id,
        input_unregister_template_object, **kwargs):
        """Delete Template Registration  # noqa: E501

        Removes an existing Template Registration from the specified Virtualization Realm.<br> <br> Note: Unregistering a Template will remove all subscriptions to the Template from other Virtualization Realms.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.unregister_template_with_http_info(id, registration_id, input_unregister_template_object, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (required)
        :param InputUnregisterTemplateObject input_unregister_template_object: The deletion settings (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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'registration_id',
            'input_unregister_template_object']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 unregister_template"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `unregister_template`'
                )
        if self.api_client.client_side_validation and ('registration_id' not in
            local_var_params or local_var_params['registration_id'] is None):
            raise ApiValueError(
                'Missing the required parameter `registration_id` when calling `unregister_template`'
                )
        if self.api_client.client_side_validation and (
            'input_unregister_template_object' not in local_var_params or 
            local_var_params['input_unregister_template_object'] is None):
            raise ApiValueError(
                'Missing the required parameter `input_unregister_template_object` when calling `unregister_template`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        if 'registration_id' in local_var_params:
            path_params['registration_id'] = local_var_params['registration_id'
                ]
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        if 'input_unregister_template_object' in local_var_params:
            body_params = local_var_params['input_unregister_template_object']
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        header_params['Content-Type'
            ] = self.api_client.select_header_content_type([
            'application/json', 'application/xml'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/registrations/{registration_id}'
            , 'DELETE', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='bool', auth_settings=auth_settings, async_req=
            local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def unshare_template_registration(self, id, registration_id,
        target_realm_id, **kwargs):
        """Unshare Template  # noqa: E501

        Revokes access to a Template Registration in the specified Virtualization Realm by the provided external Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.unshare_template_registration(id, registration_id, target_realm_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (required)
        :param int target_realm_id: ID of external virtualization realm to revoke template registration access for (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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.unshare_template_registration_with_http_info(id,
            registration_id, target_realm_id, **kwargs)

    def unshare_template_registration_with_http_info(self, id,
        registration_id, target_realm_id, **kwargs):
        """Unshare Template  # noqa: E501

        Revokes access to a Template Registration in the specified Virtualization Realm by the provided external Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.unshare_template_registration_with_http_info(id, registration_id, target_realm_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (required)
        :param int target_realm_id: ID of external virtualization realm to revoke template registration access for (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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'registration_id', 'target_realm_id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 unshare_template_registration"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `unshare_template_registration`'
                )
        if self.api_client.client_side_validation and ('registration_id' not in
            local_var_params or local_var_params['registration_id'] is None):
            raise ApiValueError(
                'Missing the required parameter `registration_id` when calling `unshare_template_registration`'
                )
        if self.api_client.client_side_validation and ('target_realm_id' not in
            local_var_params or local_var_params['target_realm_id'] is None):
            raise ApiValueError(
                'Missing the required parameter `target_realm_id` when calling `unshare_template_registration`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        if 'registration_id' in local_var_params:
            path_params['registration_id'] = local_var_params['registration_id'
                ]
        query_params = []
        if 'target_realm_id' in local_var_params and local_var_params[
            'target_realm_id'] is not None:
            query_params.append(('target_realm_id', local_var_params[
                'target_realm_id']))
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/registrations/{registration_id}/share'
            , 'DELETE', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='bool', auth_settings=auth_settings, async_req=
            local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def update_template_registration(self, id, registration_id,
        input_cons3rt_template_data, **kwargs):
        """Update Template Registration  # noqa: E501

        Updates the Template Registration for a single Virtualization Realm by the given ID.<br> <br> Note: The state of a Template Registration can only be set to OFFLINE or PUBLISHED.<br> <br> Note: All fields in Template data are honored on update, therefore any configuration that is desired in the updated Registration should be provided.  # 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_template_registration(id, registration_id, input_cons3rt_template_data, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (required)
        :param InputCons3rtTemplateData input_cons3rt_template_data: The modified template registration data (required)
        :param bool offline: The desired template registration state
        :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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.update_template_registration_with_http_info(id,
            registration_id, input_cons3rt_template_data, **kwargs)

    def update_template_registration_with_http_info(self, id,
        registration_id, input_cons3rt_template_data, **kwargs):
        """Update Template Registration  # noqa: E501

        Updates the Template Registration for a single Virtualization Realm by the given ID.<br> <br> Note: The state of a Template Registration can only be set to OFFLINE or PUBLISHED.<br> <br> Note: All fields in Template data are honored on update, therefore any configuration that is desired in the updated Registration should be provided.  # 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_template_registration_with_http_info(id, registration_id, input_cons3rt_template_data, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (required)
        :param InputCons3rtTemplateData input_cons3rt_template_data: The modified template registration data (required)
        :param bool offline: The desired template registration state
        :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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'registration_id',
            'input_cons3rt_template_data', 'offline']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_template_registration"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `update_template_registration`'
                )
        if self.api_client.client_side_validation and ('registration_id' not in
            local_var_params or local_var_params['registration_id'] is None):
            raise ApiValueError(
                'Missing the required parameter `registration_id` when calling `update_template_registration`'
                )
        if self.api_client.client_side_validation and (
            'input_cons3rt_template_data' not in local_var_params or 
            local_var_params['input_cons3rt_template_data'] is None):
            raise ApiValueError(
                'Missing the required parameter `input_cons3rt_template_data` when calling `update_template_registration`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        if 'registration_id' in local_var_params:
            path_params['registration_id'] = local_var_params['registration_id'
                ]
        query_params = []
        if 'offline' in local_var_params and local_var_params['offline'
            ] is not None:
            query_params.append(('offline', local_var_params['offline']))
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        if 'input_cons3rt_template_data' in local_var_params:
            body_params = local_var_params['input_cons3rt_template_data']
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        header_params['Content-Type'
            ] = self.api_client.select_header_content_type([
            'application/json', 'application/xml'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/registrations/{registration_id}'
            , 'PUT', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='bool', auth_settings=auth_settings, async_req=
            local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def update_template_subscription(self, id, subscription_id,
        input_template_subscription, **kwargs):
        """Update Template Subscription  # noqa: E501

        Updates the Template Subscription for a single Virtualization Realm by the given ID.<br> <br> Note: The state of a Template Subscription can only be set to OFFLINE or PUBLISHED.<br> <br> Note: The limits of a Template subscription (CPU, RAM, etc.) cannot exceed the value included in the Registration.  # 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_template_subscription(id, subscription_id, input_template_subscription, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int subscription_id: ID of template subscription (required)
        :param InputTemplateSubscription input_template_subscription: The modified template subscription data (required)
        :param bool offline: The desired template subscription state
        :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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.update_template_subscription_with_http_info(id,
            subscription_id, input_template_subscription, **kwargs)

    def update_template_subscription_with_http_info(self, id,
        subscription_id, input_template_subscription, **kwargs):
        """Update Template Subscription  # noqa: E501

        Updates the Template Subscription for a single Virtualization Realm by the given ID.<br> <br> Note: The state of a Template Subscription can only be set to OFFLINE or PUBLISHED.<br> <br> Note: The limits of a Template subscription (CPU, RAM, etc.) cannot exceed the value included in the Registration.  # 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_template_subscription_with_http_info(id, subscription_id, input_template_subscription, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int subscription_id: ID of template subscription (required)
        :param InputTemplateSubscription input_template_subscription: The modified template subscription data (required)
        :param bool offline: The desired template subscription state
        :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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'subscription_id',
            'input_template_subscription', 'offline']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_template_subscription"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `update_template_subscription`'
                )
        if self.api_client.client_side_validation and ('subscription_id' not in
            local_var_params or local_var_params['subscription_id'] is None):
            raise ApiValueError(
                'Missing the required parameter `subscription_id` when calling `update_template_subscription`'
                )
        if self.api_client.client_side_validation and (
            'input_template_subscription' not in local_var_params or 
            local_var_params['input_template_subscription'] is None):
            raise ApiValueError(
                'Missing the required parameter `input_template_subscription` when calling `update_template_subscription`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        if 'subscription_id' in local_var_params:
            path_params['subscription_id'] = local_var_params['subscription_id'
                ]
        query_params = []
        if 'offline' in local_var_params and local_var_params['offline'
            ] is not None:
            query_params.append(('offline', local_var_params['offline']))
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        if 'input_template_subscription' in local_var_params:
            body_params = local_var_params['input_template_subscription']
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        header_params['Content-Type'
            ] = self.api_client.select_header_content_type([
            'application/json', 'application/xml'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/subscriptions/{subscription_id}'
            , 'PUT', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='bool', auth_settings=auth_settings, async_req=
            local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def update_virt_realm_remote_access_config(self, id,
        remote_access_config, **kwargs):
        """Update Remote Access  # noqa: E501

        Updates the Remote Access configuration for a single Virtualization Realm by the given ID.<br> <br> Note: remoteAccessIpAddress cannot be updated if the Virtualization Realm's Remote Access is currently enabled.  # 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_virt_realm_remote_access_config(id, remote_access_config, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param RemoteAccessConfig remote_access_config: The updated remote access configuration (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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.update_virt_realm_remote_access_config_with_http_info(id,
            remote_access_config, **kwargs)

    def update_virt_realm_remote_access_config_with_http_info(self, id,
        remote_access_config, **kwargs):
        """Update Remote Access  # noqa: E501

        Updates the Remote Access configuration for a single Virtualization Realm by the given ID.<br> <br> Note: remoteAccessIpAddress cannot be updated if the Virtualization Realm's Remote Access is currently enabled.  # 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_virt_realm_remote_access_config_with_http_info(id, remote_access_config, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param RemoteAccessConfig remote_access_config: The updated remote access configuration (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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'remote_access_config']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_virt_realm_remote_access_config"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `update_virt_realm_remote_access_config`'
                )
        if self.api_client.client_side_validation and (
            'remote_access_config' not in local_var_params or 
            local_var_params['remote_access_config'] is None):
            raise ApiValueError(
                'Missing the required parameter `remote_access_config` when calling `update_virt_realm_remote_access_config`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        if 'remote_access_config' in local_var_params:
            body_params = local_var_params['remote_access_config']
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        header_params['Content-Type'
            ] = self.api_client.select_header_content_type([
            'application/json', 'application/xml'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/remoteaccess', 'PUT',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'bool', auth_settings=auth_settings, async_req=local_var_params
            .get('async_req'), _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

    def update_virtualization_realm(self, id, **kwargs):
        """Update Virtualization Realm  # noqa: E501

        Updates the content of a single Virtualization Realm with the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.update_virtualization_realm(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param InputVRAdminVirtualizationRealm input_vr_admin_virtualization_realm: The updated Virtualization Realm data
        :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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.update_virtualization_realm_with_http_info(id, **kwargs)

    def update_virtualization_realm_with_http_info(self, id, **kwargs):
        """Update Virtualization Realm  # noqa: E501

        Updates the content of a single Virtualization Realm with the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.update_virtualization_realm_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param InputVRAdminVirtualizationRealm input_vr_admin_virtualization_realm: The updated Virtualization Realm data
        :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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id', 'input_vr_admin_virtualization_realm']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_virtualization_realm"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `update_virtualization_realm`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        if 'input_vr_admin_virtualization_realm' in local_var_params:
            body_params = local_var_params[
                'input_vr_admin_virtualization_realm']
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json'])
        header_params['Content-Type'
            ] = self.api_client.select_header_content_type([
            'application/json', 'application/xml'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api('/api/virtualizationrealms/{id}',
            'PUT', path_params, query_params, header_params, body=
            body_params, post_params=form_params, files=local_var_files,
            response_type='bool', auth_settings=auth_settings, async_req=
            local_var_params.get('async_req'), _return_http_data_only=
            local_var_params.get('_return_http_data_only'),
            _preload_content=local_var_params.get('_preload_content', True),
            _request_timeout=local_var_params.get('_request_timeout'),
            collection_formats=collection_formats)

    def update_virtualization_realm_reachability(self, id, **kwargs):
        """update_virtualization_realm_reachability  # 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_virtualization_realm_reachability(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.update_virtualization_realm_reachability_with_http_info(id,
            **kwargs)

    def update_virtualization_realm_reachability_with_http_info(self, id,
        **kwargs):
        """update_virtualization_realm_reachability  # 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_virtualization_realm_reachability_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """
        local_var_params = locals()
        all_params = ['id']
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_virtualization_realm_reachability"
                     % key)
            local_var_params[key] = val
        del local_var_params['kwargs']
        if self.api_client.client_side_validation and ('id' not in
            local_var_params or local_var_params['id'] is None):
            raise ApiValueError(
                'Missing the required parameter `id` when calling `update_virtualization_realm_reachability`'
                )
        collection_formats = {}
        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']
        query_params = []
        header_params = {}
        form_params = []
        local_var_files = {}
        body_params = None
        header_params['Accept'] = self.api_client.select_header_accept([
            'application/json', 'application/xml'])
        auth_settings = ['APIKeyHeader', 'Username']
        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/updatereachability', 'PUT',
            path_params, query_params, header_params, body=body_params,
            post_params=form_params, files=local_var_files, response_type=
            'bool', auth_settings=auth_settings, async_req=local_var_params
            .get('async_req'), _return_http_data_only=local_var_params.get(
            '_return_http_data_only'), _preload_content=local_var_params.
            get('_preload_content', True), _request_timeout=
            local_var_params.get('_request_timeout'), collection_formats=
            collection_formats)

# coding: utf-8
from __future__ import absolute_import

"""
   Copyright 2020 Jackpine Technologies Corporation

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
"""
"""
cons3rt - Copyright Jackpine Technologies Corp.

NOTE: This file is auto-generated. Do not edit the file manually.
"""


from __future__ import absolute_import

import re  # noqa: F401

# python 2 and python 3 compatibility library
import six

from cons3rt.api_client import ApiClient
from cons3rt.exceptions import (
    ApiTypeError,
    ApiValueError
)

__author__ = 'Jackpine Technologies Corporation'
__copyright__ = 'Copyright 2020, Jackpine Technologies Corporation'
__license__ = 'Apache 2.0',
__version__ = '1.0.0'
__maintainer__ = 'API Support'
__email__ = 'support@cons3rt.com'


class VirtualizationRealmsApi(object):
    """NOTE: This class is auto-generated. 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 add_network(self, id, abstract_add_network_cloud_space_request, **kwargs):  # noqa: E501
        """Allocate Network  # noqa: E501

        Adds a Network to the specified Virtualization Realm.<br> <br> Since this call results in the construction of a new, back-end Network it has financial implications and should not be used if the user is not prepared to incur the expense of construction and existence of the newly created Network.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.add_network(id, abstract_add_network_cloud_space_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param AbstractAddNetworkCloudSpaceRequest abstract_add_network_cloud_space_request: The network allocation information (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: MinimalVirtualizationRealm
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.add_network_with_http_info(id, abstract_add_network_cloud_space_request, **kwargs)  # noqa: E501

    def add_network_with_http_info(self, id, abstract_add_network_cloud_space_request, **kwargs):  # noqa: E501
        """Allocate Network  # noqa: E501

        Adds a Network to the specified Virtualization Realm.<br> <br> Since this call results in the construction of a new, back-end Network it has financial implications and should not be used if the user is not prepared to incur the expense of construction and existence of the newly created Network.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.add_network_with_http_info(id, abstract_add_network_cloud_space_request, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param AbstractAddNetworkCloudSpaceRequest abstract_add_network_cloud_space_request: The network allocation information (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(MinimalVirtualizationRealm, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id', 'abstract_add_network_cloud_space_request']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 add_network" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `add_network`")  # noqa: E501
        # verify the required parameter 'abstract_add_network_cloud_space_request' is set
        if self.api_client.client_side_validation and ('abstract_add_network_cloud_space_request' not in local_var_params or  # noqa: E501
                                                        local_var_params['abstract_add_network_cloud_space_request'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `abstract_add_network_cloud_space_request` when calling `add_network`")  # noqa: E501

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/networks', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='MinimalVirtualizationRealm',  # 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 add_project(self, id, project_id, **kwargs):  # noqa: E501
        """Assign Project  # noqa: E501

        Provides members of the Project with access to the specified Virtualization Realm  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.add_project(id, project_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param str project_id: ID of project to assign (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: int
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.add_project_with_http_info(id, project_id, **kwargs)  # noqa: E501

    def add_project_with_http_info(self, id, project_id, **kwargs):  # noqa: E501
        """Assign Project  # noqa: E501

        Provides members of the Project with access to the specified Virtualization Realm  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.add_project_with_http_info(id, project_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param str project_id: ID of project to assign (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(int, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id', 'project_id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 add_project" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `add_project`")  # noqa: E501
        # verify the required parameter 'project_id' is set
        if self.api_client.client_side_validation and ('project_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['project_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `project_id` when calling `add_project`")  # noqa: E501

        collection_formats = {}

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

        query_params = []
        if 'project_id' in local_var_params and local_var_params['project_id'] is not None:  # noqa: E501
            query_params.append(('projectId', local_var_params['project_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(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/projects', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='int',  # 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_template_subsciption(self, id, registration_id, **kwargs):  # noqa: E501
        """Create Template Subscription  # noqa: E501

        Creates a Template Subscription in the specified Virtualization Realm.  # 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_template_subsciption(id, registration_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (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: FullTemplateSubscription
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.create_template_subsciption_with_http_info(id, registration_id, **kwargs)  # noqa: E501

    def create_template_subsciption_with_http_info(self, id, registration_id, **kwargs):  # noqa: E501
        """Create Template Subscription  # noqa: E501

        Creates a Template Subscription in the specified Virtualization Realm.  # 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_template_subsciption_with_http_info(id, registration_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (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(FullTemplateSubscription, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id', 'registration_id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_template_subsciption" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `create_template_subsciption`")  # noqa: E501
        # verify the required parameter 'registration_id' is set
        if self.api_client.client_side_validation and ('registration_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['registration_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `registration_id` when calling `create_template_subsciption`")  # noqa: E501

        collection_formats = {}

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

        query_params = []
        if 'registration_id' in local_var_params and local_var_params['registration_id'] is not None:  # noqa: E501
            query_params.append(('registration_id', local_var_params['registration_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(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/subscriptions', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='FullTemplateSubscription',  # 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_network(self, id, network_id, **kwargs):  # noqa: E501
        """Delete Network  # noqa: E501

        Removes an existing Network from the specified Virtualization Realm.  # 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_network(id, network_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param int network_id: ID of network (required)
        :param bool deallocate: Attempt to delete all back-end resources
        :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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.delete_network_with_http_info(id, network_id, **kwargs)  # noqa: E501

    def delete_network_with_http_info(self, id, network_id, **kwargs):  # noqa: E501
        """Delete Network  # noqa: E501

        Removes an existing Network from the specified Virtualization Realm.  # 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_network_with_http_info(id, network_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param int network_id: ID of network (required)
        :param bool deallocate: Attempt to delete all back-end resources
        :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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id', 'network_id', 'deallocate']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_network" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `delete_network`")  # noqa: E501
        # verify the required parameter 'network_id' is set
        if self.api_client.client_side_validation and ('network_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['network_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `network_id` when calling `delete_network`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501
        if 'network_id' in local_var_params:
            path_params['networkId'] = local_var_params['network_id']  # noqa: E501

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

        header_params = {}

        form_params = []
        local_var_files = {}

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

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/networks/{networkId}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='bool',  # 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_template_subscription(self, id, subscription_id, **kwargs):  # noqa: E501
        """Delete Template Subscription  # noqa: E501

        Removes an existing Template Subscription from the specified Virtualization Realm.  # 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_template_subscription(id, subscription_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int subscription_id: ID of template subscription (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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.delete_template_subscription_with_http_info(id, subscription_id, **kwargs)  # noqa: E501

    def delete_template_subscription_with_http_info(self, id, subscription_id, **kwargs):  # noqa: E501
        """Delete Template Subscription  # noqa: E501

        Removes an existing Template Subscription from the specified Virtualization Realm.  # 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_template_subscription_with_http_info(id, subscription_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int subscription_id: ID of template subscription (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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id', 'subscription_id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_template_subscription" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `delete_template_subscription`")  # noqa: E501
        # verify the required parameter 'subscription_id' is set
        if self.api_client.client_side_validation and ('subscription_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['subscription_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `subscription_id` when calling `delete_template_subscription`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501
        if 'subscription_id' in local_var_params:
            path_params['subscription_id'] = local_var_params['subscription_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(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/subscriptions/{subscription_id}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='bool',  # 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 disable_virt_realm_remote_access(self, id, **kwargs):  # noqa: E501
        """Disable Remote Access  # noqa: E501

        Disables Remote Access for a single Virtualization Realm by the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.disable_virt_realm_remote_access(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.disable_virt_realm_remote_access_with_http_info(id, **kwargs)  # noqa: E501

    def disable_virt_realm_remote_access_with_http_info(self, id, **kwargs):  # noqa: E501
        """Disable Remote Access  # noqa: E501

        Disables Remote Access for a single Virtualization Realm by the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.disable_virt_realm_remote_access_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 disable_virt_realm_remote_access" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `disable_virt_realm_remote_access`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['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(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/remoteaccess', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='bool',  # 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 enable_maintence_mode1(self, id, **kwargs):  # noqa: E501
        """Update Maintenance Mode  # noqa: E501

        Updates the maintenance status for a single Virtualization Realm by the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.enable_maintence_mode1(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param bool enable: Enable or disable maintenance mode
        :param MaintenanceModeRequest maintenance_mode_request: The maintenance mode request, when enabling maintenance mode
        :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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.enable_maintence_mode1_with_http_info(id, **kwargs)  # noqa: E501

    def enable_maintence_mode1_with_http_info(self, id, **kwargs):  # noqa: E501
        """Update Maintenance Mode  # noqa: E501

        Updates the maintenance status for a single Virtualization Realm by the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.enable_maintence_mode1_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param bool enable: Enable or disable maintenance mode
        :param MaintenanceModeRequest maintenance_mode_request: The maintenance mode request, when enabling maintenance mode
        :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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id', 'enable', 'maintenance_mode_request']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 enable_maintence_mode1" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `enable_maintence_mode1`")  # noqa: E501

        collection_formats = {}

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

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

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/maintenance', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='bool',  # 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 enable_virt_realm_remote_access(self, id, **kwargs):  # noqa: E501
        """Enable Remote Access  # noqa: E501

        Enables Remote Access for a single Virtualization Realm by the given ID.<br> <br> To do so, Remote Access must be configured for the Virtualization Realm.<br> <br> If no instanceType is provided, the Instance Type will first attempt to use the value from the Virtualization Realm's Remote Access config.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.enable_virt_realm_remote_access(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param str instance_type: Remote access server instance type
        :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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.enable_virt_realm_remote_access_with_http_info(id, **kwargs)  # noqa: E501

    def enable_virt_realm_remote_access_with_http_info(self, id, **kwargs):  # noqa: E501
        """Enable Remote Access  # noqa: E501

        Enables Remote Access for a single Virtualization Realm by the given ID.<br> <br> To do so, Remote Access must be configured for the Virtualization Realm.<br> <br> If no instanceType is provided, the Instance Type will first attempt to use the value from the Virtualization Realm's Remote Access config.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.enable_virt_realm_remote_access_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param str instance_type: Remote access server instance type
        :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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id', 'instance_type']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 enable_virt_realm_remote_access" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `enable_virt_realm_remote_access`")  # noqa: E501

        collection_formats = {}

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

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

        header_params = {}

        form_params = []
        local_var_files = {}

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

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/remoteaccess', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='bool',  # 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_deployment_runs_in_virtualization_realm(self, id, search_type, **kwargs):  # noqa: E501
        """List Deployment Runs  # noqa: E501

        Returns a collection of the Deployment Runs launched into the specified Virtualization Realm.  # 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_deployment_runs_in_virtualization_realm(id, search_type, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param str search_type: Deployment run status type (required)
        :param int maxresults: Maximum number of results to return
        :param int page: Requested page number
        :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[MinimalDeploymentRun]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_deployment_runs_in_virtualization_realm_with_http_info(id, search_type, **kwargs)  # noqa: E501

    def get_deployment_runs_in_virtualization_realm_with_http_info(self, id, search_type, **kwargs):  # noqa: E501
        """List Deployment Runs  # noqa: E501

        Returns a collection of the Deployment Runs launched into the specified Virtualization Realm.  # 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_deployment_runs_in_virtualization_realm_with_http_info(id, search_type, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param str search_type: Deployment run status type (required)
        :param int maxresults: Maximum number of results to return
        :param int page: Requested page number
        :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[MinimalDeploymentRun], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id', 'search_type', 'maxresults', 'page']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_deployment_runs_in_virtualization_realm" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `get_deployment_runs_in_virtualization_realm`")  # noqa: E501
        # verify the required parameter 'search_type' is set
        if self.api_client.client_side_validation and ('search_type' not in local_var_params or  # noqa: E501
                                                        local_var_params['search_type'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `search_type` when calling `get_deployment_runs_in_virtualization_realm`")  # noqa: E501

        collection_formats = {}

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

        query_params = []
        if 'search_type' in local_var_params and local_var_params['search_type'] is not None:  # noqa: E501
            query_params.append(('search_type', local_var_params['search_type']))  # noqa: E501
        if 'maxresults' in local_var_params and local_var_params['maxresults'] is not None:  # noqa: E501
            query_params.append(('maxresults', local_var_params['maxresults']))  # noqa: E501
        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

        header_params = {}

        form_params = []
        local_var_files = {}

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

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/deploymentruns', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[MinimalDeploymentRun]',  # 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_host_configuration_metrics1(self, id, start, end, **kwargs):  # noqa: E501
        """Retrieve Metrics  # noqa: E501

        Returns metric data for Deployment Runs launched into the specified Virtualization Realm.  # 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_host_configuration_metrics1(id, start, end, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param int start: Interval start time, specified in seconds since epoch (required)
        :param int end: Interval end time, specified in seconds since epoch (required)
        :param int interval: Number of intervals
        :param str interval_unit: Interval unit
        :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_host_configuration_metrics1_with_http_info(id, start, end, **kwargs)  # noqa: E501

    def get_host_configuration_metrics1_with_http_info(self, id, start, end, **kwargs):  # noqa: E501
        """Retrieve Metrics  # noqa: E501

        Returns metric data for Deployment Runs launched into the specified Virtualization Realm.  # 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_host_configuration_metrics1_with_http_info(id, start, end, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param int start: Interval start time, specified in seconds since epoch (required)
        :param int end: Interval end time, specified in seconds since epoch (required)
        :param int interval: Number of intervals
        :param str interval_unit: Interval unit
        :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 = ['id', 'start', 'end', 'interval', 'interval_unit']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_host_configuration_metrics1" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `get_host_configuration_metrics1`")  # noqa: E501
        # verify the required parameter 'start' is set
        if self.api_client.client_side_validation and ('start' not in local_var_params or  # noqa: E501
                                                        local_var_params['start'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `start` when calling `get_host_configuration_metrics1`")  # noqa: E501
        # verify the required parameter 'end' is set
        if self.api_client.client_side_validation and ('end' not in local_var_params or  # noqa: E501
                                                        local_var_params['end'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `end` when calling `get_host_configuration_metrics1`")  # noqa: E501

        collection_formats = {}

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

        query_params = []
        if 'start' in local_var_params and local_var_params['start'] is not None:  # noqa: E501
            query_params.append(('start', local_var_params['start']))  # noqa: E501
        if 'end' in local_var_params and local_var_params['end'] is not None:  # noqa: E501
            query_params.append(('end', local_var_params['end']))  # noqa: E501
        if 'interval' in local_var_params and local_var_params['interval'] is not None:  # noqa: E501
            query_params.append(('interval', local_var_params['interval']))  # noqa: E501
        if 'interval_unit' in local_var_params and local_var_params['interval_unit'] is not None:  # noqa: E501
            query_params.append(('intervalUnit', local_var_params['interval_unit']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

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

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/metrics/hostconfiguration', '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_network(self, id, network_id, **kwargs):  # noqa: E501
        """Retrieve Network  # noqa: E501

        Returns a single Network in the specified Virtualization Realm.  # 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_network(id, network_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param int network_id: ID of network (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: Network
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_network_with_http_info(id, network_id, **kwargs)  # noqa: E501

    def get_network_with_http_info(self, id, network_id, **kwargs):  # noqa: E501
        """Retrieve Network  # noqa: E501

        Returns a single Network in the specified Virtualization Realm.  # 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_network_with_http_info(id, network_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param int network_id: ID of network (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(Network, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id', 'network_id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_network" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `get_network`")  # noqa: E501
        # verify the required parameter 'network_id' is set
        if self.api_client.client_side_validation and ('network_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['network_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `network_id` when calling `get_network`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501
        if 'network_id' in local_var_params:
            path_params['networkId'] = local_var_params['network_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(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/networks/{networkId}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='Network',  # 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_networks(self, id, **kwargs):  # noqa: E501
        """List Networks  # noqa: E501

        Returns a collection of the Networks in the specified Virtualization Realm.  # 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_networks(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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[MinimalNetwork]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_networks_with_http_info(id, **kwargs)  # noqa: E501

    def get_networks_with_http_info(self, id, **kwargs):  # noqa: E501
        """List Networks  # noqa: E501

        Returns a collection of the Networks in the specified Virtualization Realm.  # 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_networks_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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[MinimalNetwork], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_networks" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `get_networks`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['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(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/networks', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[MinimalNetwork]',  # 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_template_subscription(self, id, subscription_id, **kwargs):  # noqa: E501
        """Retrieve Template Subscription  # noqa: E501

        Returns a single Template Subscription in the specified Virtualization Realm.  # 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_template_subscription(id, subscription_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int subscription_id: ID of template subscription (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: FullTemplateSubscription
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_template_subscription_with_http_info(id, subscription_id, **kwargs)  # noqa: E501

    def get_template_subscription_with_http_info(self, id, subscription_id, **kwargs):  # noqa: E501
        """Retrieve Template Subscription  # noqa: E501

        Returns a single Template Subscription in the specified Virtualization Realm.  # 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_template_subscription_with_http_info(id, subscription_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int subscription_id: ID of template subscription (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(FullTemplateSubscription, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id', 'subscription_id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_template_subscription" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `get_template_subscription`")  # noqa: E501
        # verify the required parameter 'subscription_id' is set
        if self.api_client.client_side_validation and ('subscription_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['subscription_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `subscription_id` when calling `get_template_subscription`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501
        if 'subscription_id' in local_var_params:
            path_params['subscription_id'] = local_var_params['subscription_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(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/subscriptions/{subscription_id}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='FullTemplateSubscription',  # 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_templates_in_virtualization_realm(self, id, **kwargs):  # noqa: E501
        """List Templates  # noqa: E501

        Returns a collection of the Templates in the specified Virtualization Realm.  # 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_templates_in_virtualization_realm(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param bool include_registrations: Include templates registered to the virtualization realm
        :param bool include_subscriptions: Include templates subscribed to by the virtualization realm
        :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[MinimalCons3rtTemplateData]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_templates_in_virtualization_realm_with_http_info(id, **kwargs)  # noqa: E501

    def get_templates_in_virtualization_realm_with_http_info(self, id, **kwargs):  # noqa: E501
        """List Templates  # noqa: E501

        Returns a collection of the Templates in the specified Virtualization Realm.  # 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_templates_in_virtualization_realm_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param bool include_registrations: Include templates registered to the virtualization realm
        :param bool include_subscriptions: Include templates subscribed to by the virtualization realm
        :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[MinimalCons3rtTemplateData], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id', 'include_registrations', 'include_subscriptions']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_templates_in_virtualization_realm" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `get_templates_in_virtualization_realm`")  # noqa: E501

        collection_formats = {}

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

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

        header_params = {}

        form_params = []
        local_var_files = {}

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

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[MinimalCons3rtTemplateData]',  # 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_unregistered_networks(self, id, **kwargs):  # noqa: E501
        """List Unregistered Networks  # noqa: E501

        Returns a collection of the unregistered, back-end Networks in the specified Virtualization Realm.  # 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_unregistered_networks(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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[Subnet]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_unregistered_networks_with_http_info(id, **kwargs)  # noqa: E501

    def get_unregistered_networks_with_http_info(self, id, **kwargs):  # noqa: E501
        """List Unregistered Networks  # noqa: E501

        Returns a collection of the unregistered, back-end Networks in the specified Virtualization Realm.  # 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_unregistered_networks_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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[Subnet], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_unregistered_networks" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `get_unregistered_networks`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['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(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/networks/unregistered', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[Subnet]',  # 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_virtual_machine_count_metrics1(self, id, start, end, **kwargs):  # noqa: E501
        """Retrieve Virtual Machine Metrics  # noqa: E501

        Returns metric data for Virtual Machines launched into the specified Virtualization Realm.  # 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_virtual_machine_count_metrics1(id, start, end, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param int start: Interval start time, specified in seconds since epoch (required)
        :param int end: Interval end time, specified in seconds since epoch (required)
        :param int interval: Number of intervals
        :param str interval_unit: Interval unit
        :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_virtual_machine_count_metrics1_with_http_info(id, start, end, **kwargs)  # noqa: E501

    def get_virtual_machine_count_metrics1_with_http_info(self, id, start, end, **kwargs):  # noqa: E501
        """Retrieve Virtual Machine Metrics  # noqa: E501

        Returns metric data for Virtual Machines launched into the specified Virtualization Realm.  # 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_virtual_machine_count_metrics1_with_http_info(id, start, end, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param int start: Interval start time, specified in seconds since epoch (required)
        :param int end: Interval end time, specified in seconds since epoch (required)
        :param int interval: Number of intervals
        :param str interval_unit: Interval unit
        :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 = ['id', 'start', 'end', 'interval', 'interval_unit']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_virtual_machine_count_metrics1" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `get_virtual_machine_count_metrics1`")  # noqa: E501
        # verify the required parameter 'start' is set
        if self.api_client.client_side_validation and ('start' not in local_var_params or  # noqa: E501
                                                        local_var_params['start'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `start` when calling `get_virtual_machine_count_metrics1`")  # noqa: E501
        # verify the required parameter 'end' is set
        if self.api_client.client_side_validation and ('end' not in local_var_params or  # noqa: E501
                                                        local_var_params['end'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `end` when calling `get_virtual_machine_count_metrics1`")  # noqa: E501

        collection_formats = {}

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

        query_params = []
        if 'start' in local_var_params and local_var_params['start'] is not None:  # noqa: E501
            query_params.append(('start', local_var_params['start']))  # noqa: E501
        if 'end' in local_var_params and local_var_params['end'] is not None:  # noqa: E501
            query_params.append(('end', local_var_params['end']))  # noqa: E501
        if 'interval' in local_var_params and local_var_params['interval'] is not None:  # noqa: E501
            query_params.append(('interval', local_var_params['interval']))  # noqa: E501
        if 'interval_unit' in local_var_params and local_var_params['interval_unit'] is not None:  # noqa: E501
            query_params.append(('intervalUnit', local_var_params['interval_unit']))  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

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

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/metrics/virtualmachinecount', '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_virtualization_realm(self, id, **kwargs):  # noqa: E501
        """Retrieve Virtualization Realm  # noqa: E501

        Returns a single Virtualization Realm by the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_virtualization_realm(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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: FullVirtualizationRealm
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_virtualization_realm_with_http_info(id, **kwargs)  # noqa: E501

    def get_virtualization_realm_with_http_info(self, id, **kwargs):  # noqa: E501
        """Retrieve Virtualization Realm  # noqa: E501

        Returns a single Virtualization Realm by the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_virtualization_realm_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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(FullVirtualizationRealm, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_virtualization_realm" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `get_virtualization_realm`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['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(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='FullVirtualizationRealm',  # 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_virtualization_realm_resources(self, id, **kwargs):  # noqa: E501
        """Retrieve Virtualization Realm Resources  # noqa: E501

        Returns the back-end resources for a single Virtualization Realm by the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_virtualization_realm_resources(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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: AbstractCloudResources
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_virtualization_realm_resources_with_http_info(id, **kwargs)  # noqa: E501

    def get_virtualization_realm_resources_with_http_info(self, id, **kwargs):  # noqa: E501
        """Retrieve Virtualization Realm Resources  # noqa: E501

        Returns the back-end resources for a single Virtualization Realm by the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.get_virtualization_realm_resources_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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(AbstractCloudResources, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_virtualization_realm_resources" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `get_virtualization_realm_resources`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['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(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/resources', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='AbstractCloudResources',  # 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_virtualization_realms(self, **kwargs):  # noqa: E501
        """List Virtualization Realms  # noqa: E501

        Returns a collection of the Virtualization Realms that the user manages.  # 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_virtualization_realms(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int maxresults: Maximum number of results to return
        :param int page: Requested page number
        :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[MinimalVirtualizationRealm]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.get_virtualization_realms_with_http_info(**kwargs)  # noqa: E501

    def get_virtualization_realms_with_http_info(self, **kwargs):  # noqa: E501
        """List Virtualization Realms  # noqa: E501

        Returns a collection of the Virtualization Realms that the user manages.  # 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_virtualization_realms_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int maxresults: Maximum number of results to return
        :param int page: Requested page number
        :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[MinimalVirtualizationRealm], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['maxresults', 'page']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_virtualization_realms" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']

        collection_formats = {}

        path_params = {}

        query_params = []
        if 'maxresults' in local_var_params and local_var_params['maxresults'] is not None:  # noqa: E501
            query_params.append(('maxresults', local_var_params['maxresults']))  # noqa: E501
        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

        header_params = {}

        form_params = []
        local_var_files = {}

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

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[MinimalVirtualizationRealm]',  # 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 invalidate_template_cache_in_virtualization_realm(self, id, **kwargs):  # noqa: E501
        """Refresh Template Cache  # noqa: E501

        Forces the back-end Template data to be re-read in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.invalidate_template_cache_in_virtualization_realm(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.invalidate_template_cache_in_virtualization_realm_with_http_info(id, **kwargs)  # noqa: E501

    def invalidate_template_cache_in_virtualization_realm_with_http_info(self, id, **kwargs):  # noqa: E501
        """Refresh Template Cache  # noqa: E501

        Forces the back-end Template data to be re-read in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.invalidate_template_cache_in_virtualization_realm_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 invalidate_template_cache_in_virtualization_realm" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `invalidate_template_cache_in_virtualization_realm`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['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(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/registrations', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='bool',  # 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 list_pending_template_subscriptions(self, id, **kwargs):  # noqa: E501
        """List Pending Subscriptions  # noqa: E501

        Returns a collection of the pending Template Subscriptions in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_pending_template_subscriptions(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (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[FullTemplateRegistrationForSubscription]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.list_pending_template_subscriptions_with_http_info(id, **kwargs)  # noqa: E501

    def list_pending_template_subscriptions_with_http_info(self, id, **kwargs):  # noqa: E501
        """List Pending Subscriptions  # noqa: E501

        Returns a collection of the pending Template Subscriptions in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_pending_template_subscriptions_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (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[FullTemplateRegistrationForSubscription], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 list_pending_template_subscriptions" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `list_pending_template_subscriptions`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['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(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/subscriptions/pending', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[FullTemplateRegistrationForSubscription]',  # 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 list_projects(self, id, **kwargs):  # noqa: E501
        """List Projects  # noqa: E501

        Returns a collection of the Projects allowed to access to the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_projects(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param int maxresults: Maximum number of results to return
        :param int page: Requested page number
        :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[MinimalProject]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.list_projects_with_http_info(id, **kwargs)  # noqa: E501

    def list_projects_with_http_info(self, id, **kwargs):  # noqa: E501
        """List Projects  # noqa: E501

        Returns a collection of the Projects allowed to access to the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_projects_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param int maxresults: Maximum number of results to return
        :param int page: Requested page number
        :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[MinimalProject], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id', 'maxresults', 'page']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 list_projects" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `list_projects`")  # noqa: E501

        collection_formats = {}

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

        query_params = []
        if 'maxresults' in local_var_params and local_var_params['maxresults'] is not None:  # noqa: E501
            query_params.append(('maxresults', local_var_params['maxresults']))  # noqa: E501
        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

        header_params = {}

        form_params = []
        local_var_files = {}

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

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/projects', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[MinimalProject]',  # 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 list_template_registrations(self, id, **kwargs):  # noqa: E501
        """List Template Registrations  # noqa: E501

        Returns a collection of the Template Registrations in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_template_registrations(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (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[MinimalTemplateRegistration]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.list_template_registrations_with_http_info(id, **kwargs)  # noqa: E501

    def list_template_registrations_with_http_info(self, id, **kwargs):  # noqa: E501
        """List Template Registrations  # noqa: E501

        Returns a collection of the Template Registrations in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_template_registrations_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (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[MinimalTemplateRegistration], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 list_template_registrations" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `list_template_registrations`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['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(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/registrations', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[MinimalTemplateRegistration]',  # 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 list_template_subscriptions(self, id, **kwargs):  # noqa: E501
        """List Template Subscriptions  # noqa: E501

        Returns a collection of the Template Subscriptions in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_template_subscriptions(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (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[MinimalTemplateSubscription]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.list_template_subscriptions_with_http_info(id, **kwargs)  # noqa: E501

    def list_template_subscriptions_with_http_info(self, id, **kwargs):  # noqa: E501
        """List Template Subscriptions  # noqa: E501

        Returns a collection of the Template Subscriptions in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_template_subscriptions_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (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[MinimalTemplateSubscription], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 list_template_subscriptions" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `list_template_subscriptions`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['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(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/subscriptions', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[MinimalTemplateSubscription]',  # 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 list_unregistered_templates(self, id, **kwargs):  # noqa: E501
        """List Unregistered Templates  # noqa: E501

        Returns a collection of the unregistered, back-end Templates in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_unregistered_templates(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (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[Cons3rtTemplateTagData]
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.list_unregistered_templates_with_http_info(id, **kwargs)  # noqa: E501

    def list_unregistered_templates_with_http_info(self, id, **kwargs):  # noqa: E501
        """List Unregistered Templates  # noqa: E501

        Returns a collection of the unregistered, back-end Templates in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.list_unregistered_templates_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (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[Cons3rtTemplateTagData], status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 list_unregistered_templates" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `list_unregistered_templates`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['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(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/registrations/pending', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='list[Cons3rtTemplateTagData]',  # 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 register_network(self, id, network_identifier, **kwargs):  # noqa: E501
        """Register Network  # noqa: E501

        Adds an existing, back-end Network the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.register_network(id, network_identifier, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param str network_identifier: Back-end network identifier (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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.register_network_with_http_info(id, network_identifier, **kwargs)  # noqa: E501

    def register_network_with_http_info(self, id, network_identifier, **kwargs):  # noqa: E501
        """Register Network  # noqa: E501

        Adds an existing, back-end Network the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.register_network_with_http_info(id, network_identifier, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param str network_identifier: Back-end network identifier (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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id', 'network_identifier']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 register_network" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `register_network`")  # noqa: E501
        # verify the required parameter 'network_identifier' is set
        if self.api_client.client_side_validation and ('network_identifier' not in local_var_params or  # noqa: E501
                                                        local_var_params['network_identifier'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `network_identifier` when calling `register_network`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501
        if 'network_identifier' in local_var_params:
            path_params['networkIdentifier'] = local_var_params['network_identifier']  # 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(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/networks/{networkIdentifier}', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='bool',  # 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 register_template(self, id, **kwargs):  # noqa: E501
        """Register Template  # noqa: E501

        Adds an existing back-end Template to the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.register_template(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param InputRegisterTemplateObject input_register_template_object: The template registration data
        :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: FullTemplateRegistration
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.register_template_with_http_info(id, **kwargs)  # noqa: E501

    def register_template_with_http_info(self, id, **kwargs):  # noqa: E501
        """Register Template  # noqa: E501

        Adds an existing back-end Template to the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.register_template_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param InputRegisterTemplateObject input_register_template_object: The template registration data
        :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(FullTemplateRegistration, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id', 'input_register_template_object']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 register_template" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `register_template`")  # noqa: E501

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/registrations', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='FullTemplateRegistration',  # 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 remove_project(self, id, project_id, **kwargs):  # noqa: E501
        """Unassign Project  # noqa: E501

        Revokes Project member access to the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.remove_project(id, project_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param str project_id: ID of project to unassign (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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.remove_project_with_http_info(id, project_id, **kwargs)  # noqa: E501

    def remove_project_with_http_info(self, id, project_id, **kwargs):  # noqa: E501
        """Unassign Project  # noqa: E501

        Revokes Project member access to the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.remove_project_with_http_info(id, project_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param str project_id: ID of project to unassign (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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id', 'project_id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 remove_project" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `remove_project`")  # noqa: E501
        # verify the required parameter 'project_id' is set
        if self.api_client.client_side_validation and ('project_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['project_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `project_id` when calling `remove_project`")  # noqa: E501

        collection_formats = {}

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

        query_params = []
        if 'project_id' in local_var_params and local_var_params['project_id'] is not None:  # noqa: E501
            query_params.append(('projectId', local_var_params['project_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(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/projects', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='bool',  # 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 retrieve_template_registration(self, id, registration_id, **kwargs):  # noqa: E501
        """Retrieve Template Registration  # noqa: E501

        Returns a single Template Registration in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_template_registration(id, registration_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (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: FullTemplateRegistration
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.retrieve_template_registration_with_http_info(id, registration_id, **kwargs)  # noqa: E501

    def retrieve_template_registration_with_http_info(self, id, registration_id, **kwargs):  # noqa: E501
        """Retrieve Template Registration  # noqa: E501

        Returns a single Template Registration in the specified Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.retrieve_template_registration_with_http_info(id, registration_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (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(FullTemplateRegistration, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id', 'registration_id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 retrieve_template_registration" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `retrieve_template_registration`")  # noqa: E501
        # verify the required parameter 'registration_id' is set
        if self.api_client.client_side_validation and ('registration_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['registration_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `registration_id` when calling `retrieve_template_registration`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501
        if 'registration_id' in local_var_params:
            path_params['registration_id'] = local_var_params['registration_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(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/registrations/{registration_id}', 'GET',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='FullTemplateRegistration',  # 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 set_virtualization_realm_active(self, id, activate, **kwargs):  # noqa: E501
        """Update State  # noqa: E501

        Updates the active State for a single Virtualization Realm by the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.set_virtualization_realm_active(id, activate, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param bool activate: Activate or deactivate virtualization realm (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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.set_virtualization_realm_active_with_http_info(id, activate, **kwargs)  # noqa: E501

    def set_virtualization_realm_active_with_http_info(self, id, activate, **kwargs):  # noqa: E501
        """Update State  # noqa: E501

        Updates the active State for a single Virtualization Realm by the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.set_virtualization_realm_active_with_http_info(id, activate, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param bool activate: Activate or deactivate virtualization realm (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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id', 'activate']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 set_virtualization_realm_active" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `set_virtualization_realm_active`")  # noqa: E501
        # verify the required parameter 'activate' is set
        if self.api_client.client_side_validation and ('activate' not in local_var_params or  # noqa: E501
                                                        local_var_params['activate'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `activate` when calling `set_virtualization_realm_active`")  # noqa: E501

        collection_formats = {}

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

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

        header_params = {}

        form_params = []
        local_var_files = {}

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

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/activate', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='bool',  # 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 share_template_registration(self, id, registration_id, target_realm_ids, **kwargs):  # noqa: E501
        """Share Template  # noqa: E501

        Shares an existing Template Registration in the specified Virtualization Realm to the provided external Virtualization Realm(s).  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.share_template_registration(id, registration_id, target_realm_ids, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (required)
        :param list[int] target_realm_ids: ID(s) of external virtualization realms to share template registration with (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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.share_template_registration_with_http_info(id, registration_id, target_realm_ids, **kwargs)  # noqa: E501

    def share_template_registration_with_http_info(self, id, registration_id, target_realm_ids, **kwargs):  # noqa: E501
        """Share Template  # noqa: E501

        Shares an existing Template Registration in the specified Virtualization Realm to the provided external Virtualization Realm(s).  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.share_template_registration_with_http_info(id, registration_id, target_realm_ids, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (required)
        :param list[int] target_realm_ids: ID(s) of external virtualization realms to share template registration with (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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id', 'registration_id', 'target_realm_ids']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 share_template_registration" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `share_template_registration`")  # noqa: E501
        # verify the required parameter 'registration_id' is set
        if self.api_client.client_side_validation and ('registration_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['registration_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `registration_id` when calling `share_template_registration`")  # noqa: E501
        # verify the required parameter 'target_realm_ids' is set
        if self.api_client.client_side_validation and ('target_realm_ids' not in local_var_params or  # noqa: E501
                                                        local_var_params['target_realm_ids'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `target_realm_ids` when calling `share_template_registration`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501
        if 'registration_id' in local_var_params:
            path_params['registration_id'] = local_var_params['registration_id']  # noqa: E501

        query_params = []
        if 'target_realm_ids' in local_var_params and local_var_params['target_realm_ids'] is not None:  # noqa: E501
            query_params.append(('target_realm_ids', local_var_params['target_realm_ids']))  # noqa: E501
            collection_formats['target_realm_ids'] = 'multi'  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

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

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/registrations/{registration_id}/share', 'POST',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='bool',  # 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 unregister_template(self, id, registration_id, input_unregister_template_object, **kwargs):  # noqa: E501
        """Delete Template Registration  # noqa: E501

        Removes an existing Template Registration from the specified Virtualization Realm.<br> <br> Note: Unregistering a Template will remove all subscriptions to the Template from other Virtualization Realms.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.unregister_template(id, registration_id, input_unregister_template_object, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (required)
        :param InputUnregisterTemplateObject input_unregister_template_object: The deletion settings (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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.unregister_template_with_http_info(id, registration_id, input_unregister_template_object, **kwargs)  # noqa: E501

    def unregister_template_with_http_info(self, id, registration_id, input_unregister_template_object, **kwargs):  # noqa: E501
        """Delete Template Registration  # noqa: E501

        Removes an existing Template Registration from the specified Virtualization Realm.<br> <br> Note: Unregistering a Template will remove all subscriptions to the Template from other Virtualization Realms.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.unregister_template_with_http_info(id, registration_id, input_unregister_template_object, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (required)
        :param InputUnregisterTemplateObject input_unregister_template_object: The deletion settings (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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id', 'registration_id', 'input_unregister_template_object']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 unregister_template" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `unregister_template`")  # noqa: E501
        # verify the required parameter 'registration_id' is set
        if self.api_client.client_side_validation and ('registration_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['registration_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `registration_id` when calling `unregister_template`")  # noqa: E501
        # verify the required parameter 'input_unregister_template_object' is set
        if self.api_client.client_side_validation and ('input_unregister_template_object' not in local_var_params or  # noqa: E501
                                                        local_var_params['input_unregister_template_object'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `input_unregister_template_object` when calling `unregister_template`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501
        if 'registration_id' in local_var_params:
            path_params['registration_id'] = local_var_params['registration_id']  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/registrations/{registration_id}', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='bool',  # 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 unshare_template_registration(self, id, registration_id, target_realm_id, **kwargs):  # noqa: E501
        """Unshare Template  # noqa: E501

        Revokes access to a Template Registration in the specified Virtualization Realm by the provided external Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.unshare_template_registration(id, registration_id, target_realm_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (required)
        :param int target_realm_id: ID of external virtualization realm to revoke template registration access for (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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.unshare_template_registration_with_http_info(id, registration_id, target_realm_id, **kwargs)  # noqa: E501

    def unshare_template_registration_with_http_info(self, id, registration_id, target_realm_id, **kwargs):  # noqa: E501
        """Unshare Template  # noqa: E501

        Revokes access to a Template Registration in the specified Virtualization Realm by the provided external Virtualization Realm.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.unshare_template_registration_with_http_info(id, registration_id, target_realm_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (required)
        :param int target_realm_id: ID of external virtualization realm to revoke template registration access for (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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id', 'registration_id', 'target_realm_id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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 unshare_template_registration" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `unshare_template_registration`")  # noqa: E501
        # verify the required parameter 'registration_id' is set
        if self.api_client.client_side_validation and ('registration_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['registration_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `registration_id` when calling `unshare_template_registration`")  # noqa: E501
        # verify the required parameter 'target_realm_id' is set
        if self.api_client.client_side_validation and ('target_realm_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['target_realm_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `target_realm_id` when calling `unshare_template_registration`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501
        if 'registration_id' in local_var_params:
            path_params['registration_id'] = local_var_params['registration_id']  # noqa: E501

        query_params = []
        if 'target_realm_id' in local_var_params and local_var_params['target_realm_id'] is not None:  # noqa: E501
            query_params.append(('target_realm_id', local_var_params['target_realm_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(
            ['application/json'])  # noqa: E501

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/registrations/{registration_id}/share', 'DELETE',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='bool',  # 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_template_registration(self, id, registration_id, input_cons3rt_template_data, **kwargs):  # noqa: E501
        """Update Template Registration  # noqa: E501

        Updates the Template Registration for a single Virtualization Realm by the given ID.<br> <br> Note: The state of a Template Registration can only be set to OFFLINE or PUBLISHED.<br> <br> Note: All fields in Template data are honored on update, therefore any configuration that is desired in the updated Registration should be provided.  # 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_template_registration(id, registration_id, input_cons3rt_template_data, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (required)
        :param InputCons3rtTemplateData input_cons3rt_template_data: The modified template registration data (required)
        :param bool offline: The desired template registration state
        :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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.update_template_registration_with_http_info(id, registration_id, input_cons3rt_template_data, **kwargs)  # noqa: E501

    def update_template_registration_with_http_info(self, id, registration_id, input_cons3rt_template_data, **kwargs):  # noqa: E501
        """Update Template Registration  # noqa: E501

        Updates the Template Registration for a single Virtualization Realm by the given ID.<br> <br> Note: The state of a Template Registration can only be set to OFFLINE or PUBLISHED.<br> <br> Note: All fields in Template data are honored on update, therefore any configuration that is desired in the updated Registration should be provided.  # 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_template_registration_with_http_info(id, registration_id, input_cons3rt_template_data, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int registration_id: ID of template registration (required)
        :param InputCons3rtTemplateData input_cons3rt_template_data: The modified template registration data (required)
        :param bool offline: The desired template registration state
        :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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id', 'registration_id', 'input_cons3rt_template_data', 'offline']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_template_registration" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `update_template_registration`")  # noqa: E501
        # verify the required parameter 'registration_id' is set
        if self.api_client.client_side_validation and ('registration_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['registration_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `registration_id` when calling `update_template_registration`")  # noqa: E501
        # verify the required parameter 'input_cons3rt_template_data' is set
        if self.api_client.client_side_validation and ('input_cons3rt_template_data' not in local_var_params or  # noqa: E501
                                                        local_var_params['input_cons3rt_template_data'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `input_cons3rt_template_data` when calling `update_template_registration`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501
        if 'registration_id' in local_var_params:
            path_params['registration_id'] = local_var_params['registration_id']  # noqa: E501

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

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/registrations/{registration_id}', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='bool',  # 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_template_subscription(self, id, subscription_id, input_template_subscription, **kwargs):  # noqa: E501
        """Update Template Subscription  # noqa: E501

        Updates the Template Subscription for a single Virtualization Realm by the given ID.<br> <br> Note: The state of a Template Subscription can only be set to OFFLINE or PUBLISHED.<br> <br> Note: The limits of a Template subscription (CPU, RAM, etc.) cannot exceed the value included in the Registration.  # 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_template_subscription(id, subscription_id, input_template_subscription, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int subscription_id: ID of template subscription (required)
        :param InputTemplateSubscription input_template_subscription: The modified template subscription data (required)
        :param bool offline: The desired template subscription state
        :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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.update_template_subscription_with_http_info(id, subscription_id, input_template_subscription, **kwargs)  # noqa: E501

    def update_template_subscription_with_http_info(self, id, subscription_id, input_template_subscription, **kwargs):  # noqa: E501
        """Update Template Subscription  # noqa: E501

        Updates the Template Subscription for a single Virtualization Realm by the given ID.<br> <br> Note: The state of a Template Subscription can only be set to OFFLINE or PUBLISHED.<br> <br> Note: The limits of a Template subscription (CPU, RAM, etc.) cannot exceed the value included in the Registration.  # 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_template_subscription_with_http_info(id, subscription_id, input_template_subscription, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param int id: ID of virtualization realm (required)
        :param int subscription_id: ID of template subscription (required)
        :param InputTemplateSubscription input_template_subscription: The modified template subscription data (required)
        :param bool offline: The desired template subscription state
        :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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id', 'subscription_id', 'input_template_subscription', 'offline']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_template_subscription" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `update_template_subscription`")  # noqa: E501
        # verify the required parameter 'subscription_id' is set
        if self.api_client.client_side_validation and ('subscription_id' not in local_var_params or  # noqa: E501
                                                        local_var_params['subscription_id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `subscription_id` when calling `update_template_subscription`")  # noqa: E501
        # verify the required parameter 'input_template_subscription' is set
        if self.api_client.client_side_validation and ('input_template_subscription' not in local_var_params or  # noqa: E501
                                                        local_var_params['input_template_subscription'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `input_template_subscription` when calling `update_template_subscription`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['id']  # noqa: E501
        if 'subscription_id' in local_var_params:
            path_params['subscription_id'] = local_var_params['subscription_id']  # noqa: E501

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

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/templates/subscriptions/{subscription_id}', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='bool',  # 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_virt_realm_remote_access_config(self, id, remote_access_config, **kwargs):  # noqa: E501
        """Update Remote Access  # noqa: E501

        Updates the Remote Access configuration for a single Virtualization Realm by the given ID.<br> <br> Note: remoteAccessIpAddress cannot be updated if the Virtualization Realm's Remote Access is currently enabled.  # 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_virt_realm_remote_access_config(id, remote_access_config, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param RemoteAccessConfig remote_access_config: The updated remote access configuration (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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.update_virt_realm_remote_access_config_with_http_info(id, remote_access_config, **kwargs)  # noqa: E501

    def update_virt_realm_remote_access_config_with_http_info(self, id, remote_access_config, **kwargs):  # noqa: E501
        """Update Remote Access  # noqa: E501

        Updates the Remote Access configuration for a single Virtualization Realm by the given ID.<br> <br> Note: remoteAccessIpAddress cannot be updated if the Virtualization Realm's Remote Access is currently enabled.  # 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_virt_realm_remote_access_config_with_http_info(id, remote_access_config, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param RemoteAccessConfig remote_access_config: The updated remote access configuration (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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id', 'remote_access_config']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_virt_realm_remote_access_config" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `update_virt_realm_remote_access_config`")  # noqa: E501
        # verify the required parameter 'remote_access_config' is set
        if self.api_client.client_side_validation and ('remote_access_config' not in local_var_params or  # noqa: E501
                                                        local_var_params['remote_access_config'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `remote_access_config` when calling `update_virt_realm_remote_access_config`")  # noqa: E501

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/remoteaccess', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='bool',  # 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_virtualization_realm(self, id, **kwargs):  # noqa: E501
        """Update Virtualization Realm  # noqa: E501

        Updates the content of a single Virtualization Realm with the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.update_virtualization_realm(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param InputVRAdminVirtualizationRealm input_vr_admin_virtualization_realm: The updated Virtualization Realm data
        :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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.update_virtualization_realm_with_http_info(id, **kwargs)  # noqa: E501

    def update_virtualization_realm_with_http_info(self, id, **kwargs):  # noqa: E501
        """Update Virtualization Realm  # noqa: E501

        Updates the content of a single Virtualization Realm with the given ID.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.update_virtualization_realm_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (required)
        :param InputVRAdminVirtualizationRealm input_vr_admin_virtualization_realm: The updated Virtualization Realm data
        :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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id', 'input_vr_admin_virtualization_realm']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_virtualization_realm" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `update_virtualization_realm`")  # noqa: E501

        collection_formats = {}

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

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

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

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='bool',  # 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_virtualization_realm_reachability(self, id, **kwargs):  # noqa: E501
        """update_virtualization_realm_reachability  # 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_virtualization_realm_reachability(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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: bool
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs['_return_http_data_only'] = True
        return self.update_virtualization_realm_reachability_with_http_info(id, **kwargs)  # noqa: E501

    def update_virtualization_realm_reachability_with_http_info(self, id, **kwargs):  # noqa: E501
        """update_virtualization_realm_reachability  # 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_virtualization_realm_reachability_with_http_info(id, async_req=True)
        >>> result = thread.get()

        :param async_req bool: execute request asynchronously
        :param str id: ID of virtualization realm (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(bool, status_code(int), headers(HTTPHeaderDict))
                 If the method is called asynchronously,
                 returns the request thread.
        """

        local_var_params = locals()

        all_params = ['id']  # noqa: E501
        all_params.append('async_req')
        all_params.append('_return_http_data_only')
        all_params.append('_preload_content')
        all_params.append('_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_virtualization_realm_reachability" % key
                )
            local_var_params[key] = val
        del local_var_params['kwargs']
        # verify the required parameter 'id' is set
        if self.api_client.client_side_validation and ('id' not in local_var_params or  # noqa: E501
                                                        local_var_params['id'] is None):  # noqa: E501
            raise ApiValueError("Missing the required parameter `id` when calling `update_virtualization_realm_reachability`")  # noqa: E501

        collection_formats = {}

        path_params = {}
        if 'id' in local_var_params:
            path_params['id'] = local_var_params['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(
            ['application/json', 'application/xml'])  # noqa: E501

        # Authentication setting
        auth_settings = ['APIKeyHeader', 'Username']  # noqa: E501

        return self.api_client.call_api(
            '/api/virtualizationrealms/{id}/updatereachability', 'PUT',
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type='bool',  # 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)
