# coding: utf-8

"""
    syntropy-controller

    No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen)  # noqa: E501

    OpenAPI spec version: 0.1.0
    
    Generated by: https://github.com/swagger-api/swagger-codegen.git
"""

from __future__ import absolute_import

import re  # noqa: F401

# python 2 and python 3 compatibility library
import six

from syntropy_sdk.api_client import ApiClient


class PlatformApi(object):
    """NOTE: This class is auto generated by the swagger code generator program.

    Do not edit the class manually.
    Ref: https://github.com/swagger-api/swagger-codegen
    """

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

    def platform_admin_agent_config(self, agent_id, **kwargs):  # noqa: E501
        """platform_admin_agent_config  # noqa: E501

        Returns agent configuration details (admin).  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_admin_agent_config(agent_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param IdNumber agent_id: (required)
        :return: PlatformResponseAdminAgentConfig_
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs["_return_http_data_only"] = True
        if kwargs.get("async_req"):
            return self.platform_admin_agent_config_with_http_info(
                agent_id, **kwargs
            )  # noqa: E501
        else:
            (data) = self.platform_admin_agent_config_with_http_info(
                agent_id, **kwargs
            )  # noqa: E501
            return data

    def platform_admin_agent_config_with_http_info(
        self, agent_id, **kwargs
    ):  # noqa: E501
        """platform_admin_agent_config  # noqa: E501

        Returns agent configuration details (admin).  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_admin_agent_config_with_http_info(agent_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param IdNumber agent_id: (required)
        :return: PlatformResponseAdminAgentConfig_
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ["agent_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")

        params = locals()
        for key, val in six.iteritems(params["kwargs"]):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method platform_admin_agent_config" % key
                )
            params[key] = val
        del params["kwargs"]
        # verify the required parameter 'agent_id' is set
        if "agent_id" not in params or params["agent_id"] is None:
            raise ValueError(
                "Missing the required parameter `agent_id` when calling `platform_admin_agent_config`"
            )  # noqa: E501

        collection_formats = {}

        path_params = {}
        if "agent_id" in params:
            path_params["agent_id"] = params["agent_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 = ["jwt"]  # noqa: E501

        return self.api_client.call_api(
            "/api/platform/admin/agent/{agent_id}/config",
            "GET",
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type="PlatformResponseAdminAgentConfig_",  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get("async_req"),
            _return_http_data_only=params.get("_return_http_data_only"),
            _preload_content=params.get("_preload_content", True),
            _request_timeout=params.get("_request_timeout"),
            collection_formats=collection_formats,
        )

    def platform_agent_config(self, agent_id, **kwargs):  # noqa: E501
        """platform_agent_config  # noqa: E501

        Returns agent configuration details.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_agent_config(agent_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param IdNumber agent_id: (required)
        :return: PlatformResponseAdminAgentConfig_
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs["_return_http_data_only"] = True
        if kwargs.get("async_req"):
            return self.platform_agent_config_with_http_info(
                agent_id, **kwargs
            )  # noqa: E501
        else:
            (data) = self.platform_agent_config_with_http_info(
                agent_id, **kwargs
            )  # noqa: E501
            return data

    def platform_agent_config_with_http_info(self, agent_id, **kwargs):  # noqa: E501
        """platform_agent_config  # noqa: E501

        Returns agent configuration details.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_agent_config_with_http_info(agent_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param IdNumber agent_id: (required)
        :return: PlatformResponseAdminAgentConfig_
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ["agent_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")

        params = locals()
        for key, val in six.iteritems(params["kwargs"]):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method platform_agent_config" % key
                )
            params[key] = val
        del params["kwargs"]
        # verify the required parameter 'agent_id' is set
        if "agent_id" not in params or params["agent_id"] is None:
            raise ValueError(
                "Missing the required parameter `agent_id` when calling `platform_agent_config`"
            )  # noqa: E501

        collection_formats = {}

        path_params = {}
        if "agent_id" in params:
            path_params["agent_id"] = params["agent_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 = ["jwt"]  # noqa: E501

        return self.api_client.call_api(
            "/api/platform/agent/{agent_id}/config",
            "GET",
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type="PlatformResponseAdminAgentConfig_",  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get("async_req"),
            _return_http_data_only=params.get("_return_http_data_only"),
            _preload_content=params.get("_preload_content", True),
            _request_timeout=params.get("_request_timeout"),
            collection_formats=collection_formats,
        )

    def platform_agent_coordinates(self, body, **kwargs):  # noqa: E501
        """platform_agent_coordinates  # noqa: E501

        Retrieves Platform agent location coordinates  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_agent_coordinates(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param Body1 body: (required)
        :return: PlatformResponseAgentCoordinatesObjectArray_
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs["_return_http_data_only"] = True
        if kwargs.get("async_req"):
            return self.platform_agent_coordinates_with_http_info(
                body, **kwargs
            )  # noqa: E501
        else:
            (data) = self.platform_agent_coordinates_with_http_info(
                body, **kwargs
            )  # noqa: E501
            return data

    def platform_agent_coordinates_with_http_info(self, body, **kwargs):  # noqa: E501
        """platform_agent_coordinates  # noqa: E501

        Retrieves Platform agent location coordinates  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_agent_coordinates_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param Body1 body: (required)
        :return: PlatformResponseAgentCoordinatesObjectArray_
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ["body"]  # noqa: E501
        all_params.append("async_req")
        all_params.append("_return_http_data_only")
        all_params.append("_preload_content")
        all_params.append("_request_timeout")

        params = locals()
        for key, val in six.iteritems(params["kwargs"]):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method platform_agent_coordinates" % key
                )
            params[key] = val
        del params["kwargs"]
        # verify the required parameter 'body' is set
        if "body" not in params or params["body"] is None:
            raise ValueError(
                "Missing the required parameter `body` when calling `platform_agent_coordinates`"
            )  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if "body" in params:
            body_params = params["body"]
        # 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"]
        )  # noqa: E501

        # Authentication setting
        auth_settings = ["jwt"]  # noqa: E501

        return self.api_client.call_api(
            "/api/platform/agents/coordinates",
            "POST",
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type="PlatformResponseAgentCoordinatesObjectArray_",  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get("async_req"),
            _return_http_data_only=params.get("_return_http_data_only"),
            _preload_content=params.get("_preload_content", True),
            _request_timeout=params.get("_request_timeout"),
            collection_formats=collection_formats,
        )

    def platform_agent_create(self, body, **kwargs):  # noqa: E501
        """platform_agent_create  # noqa: E501

        Creates new `platform agent`.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_agent_create(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param dict(str, object) body: (required)
        :return: PlatformResponseAgentObject_
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs["_return_http_data_only"] = True
        if kwargs.get("async_req"):
            return self.platform_agent_create_with_http_info(
                body, **kwargs
            )  # noqa: E501
        else:
            (data) = self.platform_agent_create_with_http_info(
                body, **kwargs
            )  # noqa: E501
            return data

    def platform_agent_create_with_http_info(self, body, **kwargs):  # noqa: E501
        """platform_agent_create  # noqa: E501

        Creates new `platform agent`.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_agent_create_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param dict(str, object) body: (required)
        :return: PlatformResponseAgentObject_
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ["body"]  # noqa: E501
        all_params.append("async_req")
        all_params.append("_return_http_data_only")
        all_params.append("_preload_content")
        all_params.append("_request_timeout")

        params = locals()
        for key, val in six.iteritems(params["kwargs"]):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method platform_agent_create" % key
                )
            params[key] = val
        del params["kwargs"]
        # verify the required parameter 'body' is set
        if "body" not in params or params["body"] is None:
            raise ValueError(
                "Missing the required parameter `body` when calling `platform_agent_create`"
            )  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if "body" in params:
            body_params = params["body"]
        # 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"]
        )  # noqa: E501

        # Authentication setting
        auth_settings = ["jwt"]  # noqa: E501

        return self.api_client.call_api(
            "/api/platform/agents",
            "POST",
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type="PlatformResponseAgentObject_",  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get("async_req"),
            _return_http_data_only=params.get("_return_http_data_only"),
            _preload_content=params.get("_preload_content", True),
            _request_timeout=params.get("_request_timeout"),
            collection_formats=collection_formats,
        )

    def platform_agent_destroy(self, agent_id, **kwargs):  # noqa: E501
        """platform_agent_destroy  # noqa: E501

        Deletes `platform agent` ands its `connections`.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_agent_destroy(agent_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param IdNumber agent_id: (required)
        :return: InlineResponse204
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs["_return_http_data_only"] = True
        if kwargs.get("async_req"):
            return self.platform_agent_destroy_with_http_info(
                agent_id, **kwargs
            )  # noqa: E501
        else:
            (data) = self.platform_agent_destroy_with_http_info(
                agent_id, **kwargs
            )  # noqa: E501
            return data

    def platform_agent_destroy_with_http_info(self, agent_id, **kwargs):  # noqa: E501
        """platform_agent_destroy  # noqa: E501

        Deletes `platform agent` ands its `connections`.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_agent_destroy_with_http_info(agent_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param IdNumber agent_id: (required)
        :return: InlineResponse204
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ["agent_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")

        params = locals()
        for key, val in six.iteritems(params["kwargs"]):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method platform_agent_destroy" % key
                )
            params[key] = val
        del params["kwargs"]
        # verify the required parameter 'agent_id' is set
        if "agent_id" not in params or params["agent_id"] is None:
            raise ValueError(
                "Missing the required parameter `agent_id` when calling `platform_agent_destroy`"
            )  # noqa: E501

        collection_formats = {}

        path_params = {}
        if "agent_id" in params:
            path_params["agent_id"] = params["agent_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 = ["jwt"]  # noqa: E501

        return self.api_client.call_api(
            "/api/platform/agents/{agent_id}",
            "DELETE",
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type="InlineResponse204",  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get("async_req"),
            _return_http_data_only=params.get("_return_http_data_only"),
            _preload_content=params.get("_preload_content", True),
            _request_timeout=params.get("_request_timeout"),
            collection_formats=collection_formats,
        )

    def platform_agent_group_destroy(self, group_id, **kwargs):  # noqa: E501
        """platform_agent_group_destroy  # noqa: E501

        Remove agent group.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_agent_group_destroy(group_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param IdNumber group_id: (required)
        :return: InlineResponse204
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs["_return_http_data_only"] = True
        if kwargs.get("async_req"):
            return self.platform_agent_group_destroy_with_http_info(
                group_id, **kwargs
            )  # noqa: E501
        else:
            (data) = self.platform_agent_group_destroy_with_http_info(
                group_id, **kwargs
            )  # noqa: E501
            return data

    def platform_agent_group_destroy_with_http_info(
        self, group_id, **kwargs
    ):  # noqa: E501
        """platform_agent_group_destroy  # noqa: E501

        Remove agent group.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_agent_group_destroy_with_http_info(group_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param IdNumber group_id: (required)
        :return: InlineResponse204
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ["group_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")

        params = locals()
        for key, val in six.iteritems(params["kwargs"]):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method platform_agent_group_destroy" % key
                )
            params[key] = val
        del params["kwargs"]
        # verify the required parameter 'group_id' is set
        if "group_id" not in params or params["group_id"] is None:
            raise ValueError(
                "Missing the required parameter `group_id` when calling `platform_agent_group_destroy`"
            )  # noqa: E501

        collection_formats = {}

        path_params = {}
        if "group_id" in params:
            path_params["group_id"] = params["group_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 = ["jwt"]  # noqa: E501

        return self.api_client.call_api(
            "/api/platform/network/agent-groups/{group_id}",
            "DELETE",
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type="InlineResponse204",  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get("async_req"),
            _return_http_data_only=params.get("_return_http_data_only"),
            _preload_content=params.get("_preload_content", True),
            _request_timeout=params.get("_request_timeout"),
            collection_formats=collection_formats,
        )

    def platform_agent_group_update(self, body, group_id, **kwargs):  # noqa: E501
        """platform_agent_group_update  # noqa: E501

        Update network agents group.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_agent_group_update(body, group_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param list[float] body: (required)
        :param IdNumber group_id: (required)
        :return: InlineResponse204
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs["_return_http_data_only"] = True
        if kwargs.get("async_req"):
            return self.platform_agent_group_update_with_http_info(
                body, group_id, **kwargs
            )  # noqa: E501
        else:
            (data) = self.platform_agent_group_update_with_http_info(
                body, group_id, **kwargs
            )  # noqa: E501
            return data

    def platform_agent_group_update_with_http_info(
        self, body, group_id, **kwargs
    ):  # noqa: E501
        """platform_agent_group_update  # noqa: E501

        Update network agents group.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_agent_group_update_with_http_info(body, group_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param list[float] body: (required)
        :param IdNumber group_id: (required)
        :return: InlineResponse204
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ["body", "group_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")

        params = locals()
        for key, val in six.iteritems(params["kwargs"]):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method platform_agent_group_update" % key
                )
            params[key] = val
        del params["kwargs"]
        # verify the required parameter 'body' is set
        if "body" not in params or params["body"] is None:
            raise ValueError(
                "Missing the required parameter `body` when calling `platform_agent_group_update`"
            )  # noqa: E501
        # verify the required parameter 'group_id' is set
        if "group_id" not in params or params["group_id"] is None:
            raise ValueError(
                "Missing the required parameter `group_id` when calling `platform_agent_group_update`"
            )  # noqa: E501

        collection_formats = {}

        path_params = {}
        if "group_id" in params:
            path_params["group_id"] = params["group_id"]  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if "body" in params:
            body_params = params["body"]
        # 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"]
        )  # noqa: E501

        # Authentication setting
        auth_settings = ["jwt"]  # noqa: E501

        return self.api_client.call_api(
            "/api/platform/network/agent-groups/{group_id}",
            "PUT",
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type="InlineResponse204",  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get("async_req"),
            _return_http_data_only=params.get("_return_http_data_only"),
            _preload_content=params.get("_preload_content", True),
            _request_timeout=params.get("_request_timeout"),
            collection_formats=collection_formats,
        )

    def platform_agent_id_name_pairs(self, **kwargs):  # noqa: E501
        """platform_agent_id_name_pairs  # noqa: E501

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

        :param async_req bool
        :param WhereString filter: ids[]: array of agent ids, example: \"1;2;3\", id|name: agent id or agent name, example: \"name1\" or \"132\", name: exact agent name, example: \"name1\", statuses[]: one of: connected, connected_with_errors, disconnected, example: \"connected;connected_with_errors\", networks[]: array of network ids, example: \"1;2;3\", providers[]: array of providers ids, example: \"1;2;3\", tags[]: array of tags ids, example: \"1;2;3\", tags_names[]: array of tags name, example: \"name1;name2;name3\", networks_names[]: array of networks names, example: \"name1;name2;name3\", connected[]: boolean to check if agent belongs to connection, example: \"true\",
        :return: PlatformResponseAgentFiltersObject_
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs["_return_http_data_only"] = True
        if kwargs.get("async_req"):
            return self.platform_agent_id_name_pairs_with_http_info(
                **kwargs
            )  # noqa: E501
        else:
            (data) = self.platform_agent_id_name_pairs_with_http_info(
                **kwargs
            )  # noqa: E501
            return data

    def platform_agent_id_name_pairs_with_http_info(self, **kwargs):  # noqa: E501
        """platform_agent_id_name_pairs  # noqa: E501

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

        :param async_req bool
        :param WhereString filter: ids[]: array of agent ids, example: \"1;2;3\", id|name: agent id or agent name, example: \"name1\" or \"132\", name: exact agent name, example: \"name1\", statuses[]: one of: connected, connected_with_errors, disconnected, example: \"connected;connected_with_errors\", networks[]: array of network ids, example: \"1;2;3\", providers[]: array of providers ids, example: \"1;2;3\", tags[]: array of tags ids, example: \"1;2;3\", tags_names[]: array of tags name, example: \"name1;name2;name3\", networks_names[]: array of networks names, example: \"name1;name2;name3\", connected[]: boolean to check if agent belongs to connection, example: \"true\",
        :return: PlatformResponseAgentFiltersObject_
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ["filter"]  # noqa: E501
        all_params.append("async_req")
        all_params.append("_return_http_data_only")
        all_params.append("_preload_content")
        all_params.append("_request_timeout")

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

        collection_formats = {}

        path_params = {}

        query_params = []
        if "filter" in params:
            query_params.append(("filter", params["filter"]))  # 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 = ["jwt"]  # noqa: E501

        return self.api_client.call_api(
            "/api/platform/agents/filters",
            "GET",
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type="PlatformResponseAgentFiltersObject_",  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get("async_req"),
            _return_http_data_only=params.get("_return_http_data_only"),
            _preload_content=params.get("_preload_content", True),
            _request_timeout=params.get("_request_timeout"),
            collection_formats=collection_formats,
        )

    def platform_agent_index(self, **kwargs):  # noqa: E501
        """platform_agent_index  # noqa: E501

        Retrieves agents.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_agent_index(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SkipNumber skip:
        :param TakeNumber take:
        :param OrderString order: string: \"ASC\" | \"DESC\"
        :param WhereString filter: ids[]: array of agent ids, example: \"1;2;3\", id|name: agent id or agent name or ip, example: \"name1\" or \"132\" or \"192.168.0.1\", name: exact agent name, example: \"name1\", types[]: array of agent types, example: Windows;macOS;Linux;Virtual, statuses[]: one of: connected, connected_with_errors, disconnected, example: \"connected;connected_with_errors\", networks[]: array of network ids, example: \"0;1;2;3\", providers[]: array of providers ids, example: \"0;1;2;3\", tags[]: array of tags ids, example: \"0;1;2;3\", tags_names[]: array of tags name, example: \"name1;name2;name3\", networks_names[]: array of networks names, example: \"name1;name2;name3\", agent_modified_at_from: date from which agent was last modified agent_modified_at_to: date to which agent was last modified agent_versions[]: array of agent versions, example: \"0.0.75;0.0.74\" locations[]: array of locations, example: \"ES;US\"
        :param bool load_relations:
        :param bool show_logs_state:
        :return: PlatformResponseAgentObjectArray_
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs["_return_http_data_only"] = True
        if kwargs.get("async_req"):
            return self.platform_agent_index_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.platform_agent_index_with_http_info(**kwargs)  # noqa: E501
            return data

    def platform_agent_index_with_http_info(self, **kwargs):  # noqa: E501
        """platform_agent_index  # noqa: E501

        Retrieves agents.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_agent_index_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SkipNumber skip:
        :param TakeNumber take:
        :param OrderString order: string: \"ASC\" | \"DESC\"
        :param WhereString filter: ids[]: array of agent ids, example: \"1;2;3\", id|name: agent id or agent name or ip, example: \"name1\" or \"132\" or \"192.168.0.1\", name: exact agent name, example: \"name1\", types[]: array of agent types, example: Windows;macOS;Linux;Virtual, statuses[]: one of: connected, connected_with_errors, disconnected, example: \"connected;connected_with_errors\", networks[]: array of network ids, example: \"0;1;2;3\", providers[]: array of providers ids, example: \"0;1;2;3\", tags[]: array of tags ids, example: \"0;1;2;3\", tags_names[]: array of tags name, example: \"name1;name2;name3\", networks_names[]: array of networks names, example: \"name1;name2;name3\", agent_modified_at_from: date from which agent was last modified agent_modified_at_to: date to which agent was last modified agent_versions[]: array of agent versions, example: \"0.0.75;0.0.74\" locations[]: array of locations, example: \"ES;US\"
        :param bool load_relations:
        :param bool show_logs_state:
        :return: PlatformResponseAgentObjectArray_
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = [
            "skip",
            "take",
            "order",
            "filter",
            "load_relations",
            "show_logs_state",
        ]  # noqa: E501
        all_params.append("async_req")
        all_params.append("_return_http_data_only")
        all_params.append("_preload_content")
        all_params.append("_request_timeout")

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

        collection_formats = {}

        path_params = {}

        query_params = []
        if "skip" in params:
            query_params.append(("skip", params["skip"]))  # noqa: E501
        if "take" in params:
            query_params.append(("take", params["take"]))  # noqa: E501
        if "order" in params:
            query_params.append(("order", params["order"]))  # noqa: E501
        if "filter" in params:
            query_params.append(("filter", params["filter"]))  # noqa: E501
        if "load_relations" in params:
            query_params.append(
                ("load-relations", params["load_relations"])
            )  # noqa: E501
        if "show_logs_state" in params:
            query_params.append(
                ("show-logs-state", params["show_logs_state"])
            )  # 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 = ["jwt"]  # noqa: E501

        return self.api_client.call_api(
            "/api/platform/agents",
            "GET",
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type="PlatformResponseAgentObjectArray_",  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get("async_req"),
            _return_http_data_only=params.get("_return_http_data_only"),
            _preload_content=params.get("_preload_content", True),
            _request_timeout=params.get("_request_timeout"),
            collection_formats=collection_formats,
        )

    def platform_agent_provider_index(self, **kwargs):  # noqa: E501
        """platform_agent_provider_index  # noqa: E501

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

        :param async_req bool
        :param SkipNumber skip:
        :param TakeNumber take:
        :param AgentProviderOrderString order:
        :return: PlatformResponseAgentProviderObjectArray_
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs["_return_http_data_only"] = True
        if kwargs.get("async_req"):
            return self.platform_agent_provider_index_with_http_info(
                **kwargs
            )  # noqa: E501
        else:
            (data) = self.platform_agent_provider_index_with_http_info(
                **kwargs
            )  # noqa: E501
            return data

    def platform_agent_provider_index_with_http_info(self, **kwargs):  # noqa: E501
        """platform_agent_provider_index  # noqa: E501

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

        :param async_req bool
        :param SkipNumber skip:
        :param TakeNumber take:
        :param AgentProviderOrderString order:
        :return: PlatformResponseAgentProviderObjectArray_
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ["skip", "take", "order"]  # noqa: E501
        all_params.append("async_req")
        all_params.append("_return_http_data_only")
        all_params.append("_preload_content")
        all_params.append("_request_timeout")

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

        collection_formats = {}

        path_params = {}

        query_params = []
        if "skip" in params:
            query_params.append(("skip", params["skip"]))  # noqa: E501
        if "take" in params:
            query_params.append(("take", params["take"]))  # noqa: E501
        if "order" in params:
            query_params.append(("order", params["order"]))  # 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 = ["jwt"]  # noqa: E501

        return self.api_client.call_api(
            "/api/platform/agent-providers",
            "GET",
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type="PlatformResponseAgentProviderObjectArray_",  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get("async_req"),
            _return_http_data_only=params.get("_return_http_data_only"),
            _preload_content=params.get("_preload_content", True),
            _request_timeout=params.get("_request_timeout"),
            collection_formats=collection_formats,
        )

    def platform_agent_provider_show(self, id, **kwargs):  # noqa: E501
        """platform_agent_provider_show  # noqa: E501

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

        :param async_req bool
        :param IdNumber id: (required)
        :return: PlatformResponseAgentProviderObject_
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs["_return_http_data_only"] = True
        if kwargs.get("async_req"):
            return self.platform_agent_provider_show_with_http_info(
                id, **kwargs
            )  # noqa: E501
        else:
            (data) = self.platform_agent_provider_show_with_http_info(
                id, **kwargs
            )  # noqa: E501
            return data

    def platform_agent_provider_show_with_http_info(self, id, **kwargs):  # noqa: E501
        """platform_agent_provider_show  # noqa: E501

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

        :param async_req bool
        :param IdNumber id: (required)
        :return: PlatformResponseAgentProviderObject_
                 If the method is called asynchronously,
                 returns the request thread.
        """

        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")

        params = locals()
        for key, val in six.iteritems(params["kwargs"]):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method platform_agent_provider_show" % key
                )
            params[key] = val
        del params["kwargs"]
        # verify the required parameter 'id' is set
        if "id" not in params or params["id"] is None:
            raise ValueError(
                "Missing the required parameter `id` when calling `platform_agent_provider_show`"
            )  # noqa: E501

        collection_formats = {}

        path_params = {}
        if "id" in params:
            path_params["id"] = 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 = ["jwt"]  # noqa: E501

        return self.api_client.call_api(
            "/api/platform/agent-providers/{id}",
            "GET",
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type="PlatformResponseAgentProviderObject_",  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get("async_req"),
            _return_http_data_only=params.get("_return_http_data_only"),
            _preload_content=params.get("_preload_content", True),
            _request_timeout=params.get("_request_timeout"),
            collection_formats=collection_formats,
        )

    def platform_agent_service_destroy(self, body, **kwargs):  # noqa: E501
        """platform_agent_service_destroy  # noqa: E501

        Deletes agent Services  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_agent_service_destroy(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param dict(str, object) body: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs["_return_http_data_only"] = True
        if kwargs.get("async_req"):
            return self.platform_agent_service_destroy_with_http_info(
                body, **kwargs
            )  # noqa: E501
        else:
            (data) = self.platform_agent_service_destroy_with_http_info(
                body, **kwargs
            )  # noqa: E501
            return data

    def platform_agent_service_destroy_with_http_info(
        self, body, **kwargs
    ):  # noqa: E501
        """platform_agent_service_destroy  # noqa: E501

        Deletes agent Services  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_agent_service_destroy_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param dict(str, object) body: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ["body"]  # noqa: E501
        all_params.append("async_req")
        all_params.append("_return_http_data_only")
        all_params.append("_preload_content")
        all_params.append("_request_timeout")

        params = locals()
        for key, val in six.iteritems(params["kwargs"]):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method platform_agent_service_destroy" % key
                )
            params[key] = val
        del params["kwargs"]
        # verify the required parameter 'body' is set
        if "body" not in params or params["body"] is None:
            raise ValueError(
                "Missing the required parameter `body` when calling `platform_agent_service_destroy`"
            )  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if "body" in params:
            body_params = params["body"]
        # HTTP header `Content-Type`
        header_params[
            "Content-Type"
        ] = self.api_client.select_header_content_type(  # noqa: E501
            ["application/json"]
        )  # noqa: E501

        # Authentication setting
        auth_settings = ["jwt"]  # noqa: E501

        return self.api_client.call_api(
            "/api/platform/agent-services-delete",
            "POST",
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get("async_req"),
            _return_http_data_only=params.get("_return_http_data_only"),
            _preload_content=params.get("_preload_content", True),
            _request_timeout=params.get("_request_timeout"),
            collection_formats=collection_formats,
        )

    def platform_agent_service_index(self, agent_ids, **kwargs):  # noqa: E501
        """platform_agent_service_index  # noqa: E501

        Retrieves agent services.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_agent_service_index(agent_ids, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param list[float] agent_ids: (required)
        :return: PlatformResponseAgentServiceObjectArray_
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs["_return_http_data_only"] = True
        if kwargs.get("async_req"):
            return self.platform_agent_service_index_with_http_info(
                agent_ids, **kwargs
            )  # noqa: E501
        else:
            (data) = self.platform_agent_service_index_with_http_info(
                agent_ids, **kwargs
            )  # noqa: E501
            return data

    def platform_agent_service_index_with_http_info(
        self, agent_ids, **kwargs
    ):  # noqa: E501
        """platform_agent_service_index  # noqa: E501

        Retrieves agent services.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_agent_service_index_with_http_info(agent_ids, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param list[float] agent_ids: (required)
        :return: PlatformResponseAgentServiceObjectArray_
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ["agent_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")

        params = locals()
        for key, val in six.iteritems(params["kwargs"]):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method platform_agent_service_index" % key
                )
            params[key] = val
        del params["kwargs"]
        # verify the required parameter 'agent_ids' is set
        if "agent_ids" not in params or params["agent_ids"] is None:
            raise ValueError(
                "Missing the required parameter `agent_ids` when calling `platform_agent_service_index`"
            )  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []
        if "agent_ids" in params:
            query_params.append(("agent-ids", params["agent_ids"]))  # noqa: E501
            collection_formats["agent-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 = ["jwt"]  # noqa: E501

        return self.api_client.call_api(
            "/api/platform/agent-services",
            "GET",
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type="PlatformResponseAgentServiceObjectArray_",  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get("async_req"),
            _return_http_data_only=params.get("_return_http_data_only"),
            _preload_content=params.get("_preload_content", True),
            _request_timeout=params.get("_request_timeout"),
            collection_formats=collection_formats,
        )

    def platform_agent_service_subnet_update(self, body, **kwargs):  # noqa: E501
        """platform_agent_service_subnet_update  # noqa: E501

        Updates agent services status  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_agent_service_subnet_update(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param dict(str, object) body: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs["_return_http_data_only"] = True
        if kwargs.get("async_req"):
            return self.platform_agent_service_subnet_update_with_http_info(
                body, **kwargs
            )  # noqa: E501
        else:
            (data) = self.platform_agent_service_subnet_update_with_http_info(
                body, **kwargs
            )  # noqa: E501
            return data

    def platform_agent_service_subnet_update_with_http_info(
        self, body, **kwargs
    ):  # noqa: E501
        """platform_agent_service_subnet_update  # noqa: E501

        Updates agent services status  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_agent_service_subnet_update_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param dict(str, object) body: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ["body"]  # noqa: E501
        all_params.append("async_req")
        all_params.append("_return_http_data_only")
        all_params.append("_preload_content")
        all_params.append("_request_timeout")

        params = locals()
        for key, val in six.iteritems(params["kwargs"]):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method platform_agent_service_subnet_update" % key
                )
            params[key] = val
        del params["kwargs"]
        # verify the required parameter 'body' is set
        if "body" not in params or params["body"] is None:
            raise ValueError(
                "Missing the required parameter `body` when calling `platform_agent_service_subnet_update`"
            )  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if "body" in params:
            body_params = params["body"]
        # HTTP header `Content-Type`
        header_params[
            "Content-Type"
        ] = self.api_client.select_header_content_type(  # noqa: E501
            ["application/json"]
        )  # noqa: E501

        # Authentication setting
        auth_settings = ["jwt"]  # noqa: E501

        return self.api_client.call_api(
            "/api/platform/agent-services-subnets",
            "POST",
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get("async_req"),
            _return_http_data_only=params.get("_return_http_data_only"),
            _preload_content=params.get("_preload_content", True),
            _request_timeout=params.get("_request_timeout"),
            collection_formats=collection_formats,
        )

    def platform_agent_tag_index(self, **kwargs):  # noqa: E501
        """platform_agent_tag_index  # noqa: E501

        Get user agent tags.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_agent_tag_index(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :return: PlatformResponseAgentTagObjectArray_
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs["_return_http_data_only"] = True
        if kwargs.get("async_req"):
            return self.platform_agent_tag_index_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.platform_agent_tag_index_with_http_info(
                **kwargs
            )  # noqa: E501
            return data

    def platform_agent_tag_index_with_http_info(self, **kwargs):  # noqa: E501
        """platform_agent_tag_index  # noqa: E501

        Get user agent tags.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_agent_tag_index_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :return: PlatformResponseAgentTagObjectArray_
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = []  # noqa: E501
        all_params.append("async_req")
        all_params.append("_return_http_data_only")
        all_params.append("_preload_content")
        all_params.append("_request_timeout")

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

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

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

        # Authentication setting
        auth_settings = ["jwt"]  # noqa: E501

        return self.api_client.call_api(
            "/api/platform/agent-tags",
            "GET",
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type="PlatformResponseAgentTagObjectArray_",  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get("async_req"),
            _return_http_data_only=params.get("_return_http_data_only"),
            _preload_content=params.get("_preload_content", True),
            _request_timeout=params.get("_request_timeout"),
            collection_formats=collection_formats,
        )

    def platform_agent_update(self, body, agent_id, **kwargs):  # noqa: E501
        """platform_agent_update  # noqa: E501

        Patches agent.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_agent_update(body, agent_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param dict(str, object) body: (required)
        :param IdNumber agent_id: (required)
        :return: PlatformResponseSuccessBoolean_
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs["_return_http_data_only"] = True
        if kwargs.get("async_req"):
            return self.platform_agent_update_with_http_info(
                body, agent_id, **kwargs
            )  # noqa: E501
        else:
            (data) = self.platform_agent_update_with_http_info(
                body, agent_id, **kwargs
            )  # noqa: E501
            return data

    def platform_agent_update_with_http_info(
        self, body, agent_id, **kwargs
    ):  # noqa: E501
        """platform_agent_update  # noqa: E501

        Patches agent.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_agent_update_with_http_info(body, agent_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param dict(str, object) body: (required)
        :param IdNumber agent_id: (required)
        :return: PlatformResponseSuccessBoolean_
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ["body", "agent_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")

        params = locals()
        for key, val in six.iteritems(params["kwargs"]):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method platform_agent_update" % key
                )
            params[key] = val
        del params["kwargs"]
        # verify the required parameter 'body' is set
        if "body" not in params or params["body"] is None:
            raise ValueError(
                "Missing the required parameter `body` when calling `platform_agent_update`"
            )  # noqa: E501
        # verify the required parameter 'agent_id' is set
        if "agent_id" not in params or params["agent_id"] is None:
            raise ValueError(
                "Missing the required parameter `agent_id` when calling `platform_agent_update`"
            )  # noqa: E501

        collection_formats = {}

        path_params = {}
        if "agent_id" in params:
            path_params["agent_id"] = params["agent_id"]  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if "body" in params:
            body_params = params["body"]
        # 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"]
        )  # noqa: E501

        # Authentication setting
        auth_settings = ["jwt"]  # noqa: E501

        return self.api_client.call_api(
            "/api/platform/agents/{agent_id}",
            "PATCH",
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type="PlatformResponseSuccessBoolean_",  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get("async_req"),
            _return_http_data_only=params.get("_return_http_data_only"),
            _preload_content=params.get("_preload_content", True),
            _request_timeout=params.get("_request_timeout"),
            collection_formats=collection_formats,
        )

    def platform_agents_destroy(self, body, **kwargs):  # noqa: E501
        """platform_agents_destroy  # noqa: E501

        Deletes `platform agent` ands its `connections`.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_agents_destroy(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param list[AgentsObject] body: (required)
        :return: InlineResponse204
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs["_return_http_data_only"] = True
        if kwargs.get("async_req"):
            return self.platform_agents_destroy_with_http_info(
                body, **kwargs
            )  # noqa: E501
        else:
            (data) = self.platform_agents_destroy_with_http_info(
                body, **kwargs
            )  # noqa: E501
            return data

    def platform_agents_destroy_with_http_info(self, body, **kwargs):  # noqa: E501
        """platform_agents_destroy  # noqa: E501

        Deletes `platform agent` ands its `connections`.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_agents_destroy_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param list[AgentsObject] body: (required)
        :return: InlineResponse204
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ["body"]  # noqa: E501
        all_params.append("async_req")
        all_params.append("_return_http_data_only")
        all_params.append("_preload_content")
        all_params.append("_request_timeout")

        params = locals()
        for key, val in six.iteritems(params["kwargs"]):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method platform_agents_destroy" % key
                )
            params[key] = val
        del params["kwargs"]
        # verify the required parameter 'body' is set
        if "body" not in params or params["body"] is None:
            raise ValueError(
                "Missing the required parameter `body` when calling `platform_agents_destroy`"
            )  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if "body" in params:
            body_params = params["body"]
        # 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"]
        )  # noqa: E501

        # Authentication setting
        auth_settings = ["jwt"]  # noqa: E501

        return self.api_client.call_api(
            "/api/platform/agents/remove",
            "POST",
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type="InlineResponse204",  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get("async_req"),
            _return_http_data_only=params.get("_return_http_data_only"),
            _preload_content=params.get("_preload_content", True),
            _request_timeout=params.get("_request_timeout"),
            collection_formats=collection_formats,
        )

    def platform_api_key_create(self, body, **kwargs):  # noqa: E501
        """platform_api_key_create  # noqa: E501

        Creates API key.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_api_key_create(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param dict(str, object) body: (required)
        :return: PlatformResponseApiKeyObject_
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs["_return_http_data_only"] = True
        if kwargs.get("async_req"):
            return self.platform_api_key_create_with_http_info(
                body, **kwargs
            )  # noqa: E501
        else:
            (data) = self.platform_api_key_create_with_http_info(
                body, **kwargs
            )  # noqa: E501
            return data

    def platform_api_key_create_with_http_info(self, body, **kwargs):  # noqa: E501
        """platform_api_key_create  # noqa: E501

        Creates API key.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_api_key_create_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param dict(str, object) body: (required)
        :return: PlatformResponseApiKeyObject_
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ["body"]  # noqa: E501
        all_params.append("async_req")
        all_params.append("_return_http_data_only")
        all_params.append("_preload_content")
        all_params.append("_request_timeout")

        params = locals()
        for key, val in six.iteritems(params["kwargs"]):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method platform_api_key_create" % key
                )
            params[key] = val
        del params["kwargs"]
        # verify the required parameter 'body' is set
        if "body" not in params or params["body"] is None:
            raise ValueError(
                "Missing the required parameter `body` when calling `platform_api_key_create`"
            )  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if "body" in params:
            body_params = params["body"]
        # 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"]
        )  # noqa: E501

        # Authentication setting
        auth_settings = ["jwt"]  # noqa: E501

        return self.api_client.call_api(
            "/api/platform/api-keys",
            "POST",
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type="PlatformResponseApiKeyObject_",  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get("async_req"),
            _return_http_data_only=params.get("_return_http_data_only"),
            _preload_content=params.get("_preload_content", True),
            _request_timeout=params.get("_request_timeout"),
            collection_formats=collection_formats,
        )

    def platform_api_key_destroy(self, api_key_id, **kwargs):  # noqa: E501
        """platform_api_key_destroy  # noqa: E501

        Deletes API key.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_api_key_destroy(api_key_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param IdNumber api_key_id: (required)
        :return: InlineResponse204
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs["_return_http_data_only"] = True
        if kwargs.get("async_req"):
            return self.platform_api_key_destroy_with_http_info(
                api_key_id, **kwargs
            )  # noqa: E501
        else:
            (data) = self.platform_api_key_destroy_with_http_info(
                api_key_id, **kwargs
            )  # noqa: E501
            return data

    def platform_api_key_destroy_with_http_info(
        self, api_key_id, **kwargs
    ):  # noqa: E501
        """platform_api_key_destroy  # noqa: E501

        Deletes API key.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_api_key_destroy_with_http_info(api_key_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param IdNumber api_key_id: (required)
        :return: InlineResponse204
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ["api_key_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")

        params = locals()
        for key, val in six.iteritems(params["kwargs"]):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method platform_api_key_destroy" % key
                )
            params[key] = val
        del params["kwargs"]
        # verify the required parameter 'api_key_id' is set
        if "api_key_id" not in params or params["api_key_id"] is None:
            raise ValueError(
                "Missing the required parameter `api_key_id` when calling `platform_api_key_destroy`"
            )  # noqa: E501

        collection_formats = {}

        path_params = {}
        if "api_key_id" in params:
            path_params["api_key_id"] = params["api_key_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 = ["jwt"]  # noqa: E501

        return self.api_client.call_api(
            "/api/platform/api-keys/{api_key_id}",
            "DELETE",
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type="InlineResponse204",  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get("async_req"),
            _return_http_data_only=params.get("_return_http_data_only"),
            _preload_content=params.get("_preload_content", True),
            _request_timeout=params.get("_request_timeout"),
            collection_formats=collection_formats,
        )

    def platform_api_key_index(self, **kwargs):  # noqa: E501
        """platform_api_key_index  # noqa: E501

        Get API keys.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_api_key_index(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SkipNumber skip:
        :param TakeNumber take:
        :param str order: string: \"ASC\" | \"DESC\"
        :param str filter: api_key_id: string, api_key_name: string
        :return: PlatformResponseApiKeyObjectArray_
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs["_return_http_data_only"] = True
        if kwargs.get("async_req"):
            return self.platform_api_key_index_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.platform_api_key_index_with_http_info(**kwargs)  # noqa: E501
            return data

    def platform_api_key_index_with_http_info(self, **kwargs):  # noqa: E501
        """platform_api_key_index  # noqa: E501

        Get API keys.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_api_key_index_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SkipNumber skip:
        :param TakeNumber take:
        :param str order: string: \"ASC\" | \"DESC\"
        :param str filter: api_key_id: string, api_key_name: string
        :return: PlatformResponseApiKeyObjectArray_
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ["skip", "take", "order", "filter"]  # noqa: E501
        all_params.append("async_req")
        all_params.append("_return_http_data_only")
        all_params.append("_preload_content")
        all_params.append("_request_timeout")

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

        collection_formats = {}

        path_params = {}

        query_params = []
        if "skip" in params:
            query_params.append(("skip", params["skip"]))  # noqa: E501
        if "take" in params:
            query_params.append(("take", params["take"]))  # noqa: E501
        if "order" in params:
            query_params.append(("order", params["order"]))  # noqa: E501
        if "filter" in params:
            query_params.append(("filter", params["filter"]))  # 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 = ["jwt"]  # noqa: E501

        return self.api_client.call_api(
            "/api/platform/api-keys",
            "GET",
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type="PlatformResponseApiKeyObjectArray_",  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get("async_req"),
            _return_http_data_only=params.get("_return_http_data_only"),
            _preload_content=params.get("_preload_content", True),
            _request_timeout=params.get("_request_timeout"),
            collection_formats=collection_formats,
        )

    def platform_config(self, agent_id, **kwargs):  # noqa: E501
        """platform_config  # noqa: E501

        Returns `platform agent` `WireGuard` configuration.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_config(agent_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param IdNumber agent_id: (required)
        :return: PlatformResponse5BLinkTagPublic5D3F3Astring5BLinkTagSdn15D3F3Astring5BLinkTagSdn25D3F3Astring5BLinkTagSdn35D3F3Astring_
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs["_return_http_data_only"] = True
        if kwargs.get("async_req"):
            return self.platform_config_with_http_info(agent_id, **kwargs)  # noqa: E501
        else:
            (data) = self.platform_config_with_http_info(
                agent_id, **kwargs
            )  # noqa: E501
            return data

    def platform_config_with_http_info(self, agent_id, **kwargs):  # noqa: E501
        """platform_config  # noqa: E501

        Returns `platform agent` `WireGuard` configuration.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_config_with_http_info(agent_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param IdNumber agent_id: (required)
        :return: PlatformResponse5BLinkTagPublic5D3F3Astring5BLinkTagSdn15D3F3Astring5BLinkTagSdn25D3F3Astring5BLinkTagSdn35D3F3Astring_
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ["agent_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")

        params = locals()
        for key, val in six.iteritems(params["kwargs"]):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method platform_config" % key
                )
            params[key] = val
        del params["kwargs"]
        # verify the required parameter 'agent_id' is set
        if "agent_id" not in params or params["agent_id"] is None:
            raise ValueError(
                "Missing the required parameter `agent_id` when calling `platform_config`"
            )  # noqa: E501

        collection_formats = {}

        path_params = {}
        if "agent_id" in params:
            path_params["agent_id"] = params["agent_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 = ["jwt"]  # noqa: E501

        return self.api_client.call_api(
            "/api/platform/agent/{agent_id}/wg-config",
            "GET",
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type="PlatformResponse5BLinkTagPublic5D3F3Astring5BLinkTagSdn15D3F3Astring5BLinkTagSdn25D3F3Astring5BLinkTagSdn35D3F3Astring_",  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get("async_req"),
            _return_http_data_only=params.get("_return_http_data_only"),
            _preload_content=params.get("_preload_content", True),
            _request_timeout=params.get("_request_timeout"),
            collection_formats=collection_formats,
        )

    def platform_connection_agent_destroy(self, agent_id, **kwargs):  # noqa: E501
        """platform_connection_agent_destroy  # noqa: E501

        Deletes agent `connections`. Does not remove `platform agent` from `networks`.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_connection_agent_destroy(agent_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param IdNumber agent_id: (required)
        :return: InlineResponse204
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs["_return_http_data_only"] = True
        if kwargs.get("async_req"):
            return self.platform_connection_agent_destroy_with_http_info(
                agent_id, **kwargs
            )  # noqa: E501
        else:
            (data) = self.platform_connection_agent_destroy_with_http_info(
                agent_id, **kwargs
            )  # noqa: E501
            return data

    def platform_connection_agent_destroy_with_http_info(
        self, agent_id, **kwargs
    ):  # noqa: E501
        """platform_connection_agent_destroy  # noqa: E501

        Deletes agent `connections`. Does not remove `platform agent` from `networks`.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_connection_agent_destroy_with_http_info(agent_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param IdNumber agent_id: (required)
        :return: InlineResponse204
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ["agent_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")

        params = locals()
        for key, val in six.iteritems(params["kwargs"]):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method platform_connection_agent_destroy" % key
                )
            params[key] = val
        del params["kwargs"]
        # verify the required parameter 'agent_id' is set
        if "agent_id" not in params or params["agent_id"] is None:
            raise ValueError(
                "Missing the required parameter `agent_id` when calling `platform_connection_agent_destroy`"
            )  # noqa: E501

        collection_formats = {}

        path_params = {}
        if "agent_id" in params:
            path_params["agent_id"] = params["agent_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 = ["jwt"]  # noqa: E501

        return self.api_client.call_api(
            "/api/platform/connections/agents/{agent_id}",
            "DELETE",
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type="InlineResponse204",  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get("async_req"),
            _return_http_data_only=params.get("_return_http_data_only"),
            _preload_content=params.get("_preload_content", True),
            _request_timeout=params.get("_request_timeout"),
            collection_formats=collection_formats,
        )

    def platform_connection_agents_destroy(self, body, **kwargs):  # noqa: E501
        """platform_connection_agents_destroy  # noqa: E501

        Deletes agent `connections`. Does not remove `platform agent` from `networks`.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_connection_agents_destroy(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param list[AgentsObject] body: (required)
        :return: InlineResponse204
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs["_return_http_data_only"] = True
        if kwargs.get("async_req"):
            return self.platform_connection_agents_destroy_with_http_info(
                body, **kwargs
            )  # noqa: E501
        else:
            (data) = self.platform_connection_agents_destroy_with_http_info(
                body, **kwargs
            )  # noqa: E501
            return data

    def platform_connection_agents_destroy_with_http_info(
        self, body, **kwargs
    ):  # noqa: E501
        """platform_connection_agents_destroy  # noqa: E501

        Deletes agent `connections`. Does not remove `platform agent` from `networks`.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_connection_agents_destroy_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param list[AgentsObject] body: (required)
        :return: InlineResponse204
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ["body"]  # noqa: E501
        all_params.append("async_req")
        all_params.append("_return_http_data_only")
        all_params.append("_preload_content")
        all_params.append("_request_timeout")

        params = locals()
        for key, val in six.iteritems(params["kwargs"]):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method platform_connection_agents_destroy" % key
                )
            params[key] = val
        del params["kwargs"]
        # verify the required parameter 'body' is set
        if "body" not in params or params["body"] is None:
            raise ValueError(
                "Missing the required parameter `body` when calling `platform_connection_agents_destroy`"
            )  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if "body" in params:
            body_params = params["body"]
        # 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"]
        )  # noqa: E501

        # Authentication setting
        auth_settings = ["jwt"]  # noqa: E501

        return self.api_client.call_api(
            "/api/platform/connections/agents/remove",
            "POST",
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type="InlineResponse204",  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get("async_req"),
            _return_http_data_only=params.get("_return_http_data_only"),
            _preload_content=params.get("_preload_content", True),
            _request_timeout=params.get("_request_timeout"),
            collection_formats=collection_formats,
        )

    def platform_connection_create(self, body, **kwargs):  # noqa: E501
        """platform_connection_create  # noqa: E501

        Creates agents connections. If connection type is POINT_TO_POINT, then agent_ids should contain pairs of ids, i.e.: [[1,2], [2,3], ...]. In other types of networks a flat array of ids should be passed, i.e.: [1, 2, 3, ...].  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_connection_create(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param dict(str, object) body: (required)
        :param list[str] paths: Comma separated servers ids list for SDN path.
        :return: PlatformResponseAgentConnectionObjectArray_
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs["_return_http_data_only"] = True
        if kwargs.get("async_req"):
            return self.platform_connection_create_with_http_info(
                body, **kwargs
            )  # noqa: E501
        else:
            (data) = self.platform_connection_create_with_http_info(
                body, **kwargs
            )  # noqa: E501
            return data

    def platform_connection_create_with_http_info(self, body, **kwargs):  # noqa: E501
        """platform_connection_create  # noqa: E501

        Creates agents connections. If connection type is POINT_TO_POINT, then agent_ids should contain pairs of ids, i.e.: [[1,2], [2,3], ...]. In other types of networks a flat array of ids should be passed, i.e.: [1, 2, 3, ...].  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_connection_create_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param dict(str, object) body: (required)
        :param list[str] paths: Comma separated servers ids list for SDN path.
        :return: PlatformResponseAgentConnectionObjectArray_
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ["body", "paths"]  # noqa: E501
        all_params.append("async_req")
        all_params.append("_return_http_data_only")
        all_params.append("_preload_content")
        all_params.append("_request_timeout")

        params = locals()
        for key, val in six.iteritems(params["kwargs"]):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method platform_connection_create" % key
                )
            params[key] = val
        del params["kwargs"]
        # verify the required parameter 'body' is set
        if "body" not in params or params["body"] is None:
            raise ValueError(
                "Missing the required parameter `body` when calling `platform_connection_create`"
            )  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []
        if "paths" in params:
            query_params.append(("paths", params["paths"]))  # noqa: E501
            collection_formats["paths"] = "multi"  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if "body" in params:
            body_params = params["body"]
        # 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"]
        )  # noqa: E501

        # Authentication setting
        auth_settings = ["jwt"]  # noqa: E501

        return self.api_client.call_api(
            "/api/platform/connections",
            "POST",
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type="PlatformResponseAgentConnectionObjectArray_",  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get("async_req"),
            _return_http_data_only=params.get("_return_http_data_only"),
            _preload_content=params.get("_preload_content", True),
            _request_timeout=params.get("_request_timeout"),
            collection_formats=collection_formats,
        )

    def platform_connection_create_mesh(self, body, **kwargs):  # noqa: E501
        """platform_connection_create_mesh  # noqa: E501

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

        :param async_req bool
        :param dict(str, object) body: (required)
        :param list[str] paths: Comma separated servers ids list for SDN path.
        :return: PlatformResponseAgentConnectionObjectArray_
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs["_return_http_data_only"] = True
        if kwargs.get("async_req"):
            return self.platform_connection_create_mesh_with_http_info(
                body, **kwargs
            )  # noqa: E501
        else:
            (data) = self.platform_connection_create_mesh_with_http_info(
                body, **kwargs
            )  # noqa: E501
            return data

    def platform_connection_create_mesh_with_http_info(
        self, body, **kwargs
    ):  # noqa: E501
        """platform_connection_create_mesh  # noqa: E501

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

        :param async_req bool
        :param dict(str, object) body: (required)
        :param list[str] paths: Comma separated servers ids list for SDN path.
        :return: PlatformResponseAgentConnectionObjectArray_
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ["body", "paths"]  # noqa: E501
        all_params.append("async_req")
        all_params.append("_return_http_data_only")
        all_params.append("_preload_content")
        all_params.append("_request_timeout")

        params = locals()
        for key, val in six.iteritems(params["kwargs"]):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method platform_connection_create_mesh" % key
                )
            params[key] = val
        del params["kwargs"]
        # verify the required parameter 'body' is set
        if "body" not in params or params["body"] is None:
            raise ValueError(
                "Missing the required parameter `body` when calling `platform_connection_create_mesh`"
            )  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []
        if "paths" in params:
            query_params.append(("paths", params["paths"]))  # noqa: E501
            collection_formats["paths"] = "multi"  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if "body" in params:
            body_params = params["body"]
        # 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"]
        )  # noqa: E501

        # Authentication setting
        auth_settings = ["jwt"]  # noqa: E501

        return self.api_client.call_api(
            "/api/platform/connections/mesh",
            "POST",
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type="PlatformResponseAgentConnectionObjectArray_",  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get("async_req"),
            _return_http_data_only=params.get("_return_http_data_only"),
            _preload_content=params.get("_preload_content", True),
            _request_timeout=params.get("_request_timeout"),
            collection_formats=collection_formats,
        )

    def platform_connection_create_p2p(self, body, **kwargs):  # noqa: E501
        """platform_connection_create_p2p  # noqa: E501

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

        :param async_req bool
        :param dict(str, object) body: (required)
        :param list[str] paths: Comma separated servers ids list for SDN path.
        :return: PlatformResponseAgentConnectionObjectArray_
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs["_return_http_data_only"] = True
        if kwargs.get("async_req"):
            return self.platform_connection_create_p2p_with_http_info(
                body, **kwargs
            )  # noqa: E501
        else:
            (data) = self.platform_connection_create_p2p_with_http_info(
                body, **kwargs
            )  # noqa: E501
            return data

    def platform_connection_create_p2p_with_http_info(
        self, body, **kwargs
    ):  # noqa: E501
        """platform_connection_create_p2p  # noqa: E501

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

        :param async_req bool
        :param dict(str, object) body: (required)
        :param list[str] paths: Comma separated servers ids list for SDN path.
        :return: PlatformResponseAgentConnectionObjectArray_
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ["body", "paths"]  # noqa: E501
        all_params.append("async_req")
        all_params.append("_return_http_data_only")
        all_params.append("_preload_content")
        all_params.append("_request_timeout")

        params = locals()
        for key, val in six.iteritems(params["kwargs"]):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method platform_connection_create_p2p" % key
                )
            params[key] = val
        del params["kwargs"]
        # verify the required parameter 'body' is set
        if "body" not in params or params["body"] is None:
            raise ValueError(
                "Missing the required parameter `body` when calling `platform_connection_create_p2p`"
            )  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []
        if "paths" in params:
            query_params.append(("paths", params["paths"]))  # noqa: E501
            collection_formats["paths"] = "multi"  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if "body" in params:
            body_params = params["body"]
        # 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"]
        )  # noqa: E501

        # Authentication setting
        auth_settings = ["jwt"]  # noqa: E501

        return self.api_client.call_api(
            "/api/platform/connections/point-to-point",
            "POST",
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type="PlatformResponseAgentConnectionObjectArray_",  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get("async_req"),
            _return_http_data_only=params.get("_return_http_data_only"),
            _preload_content=params.get("_preload_content", True),
            _request_timeout=params.get("_request_timeout"),
            collection_formats=collection_formats,
        )

    def platform_connection_destroy(self, body, **kwargs):  # noqa: E501
        """platform_connection_destroy  # noqa: E501

        Deletes `connections` by supplied pairs of `platform agents`.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_connection_destroy(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param list[AgentsPairObject] body: (required)
        :param NetworkGenesisType network_updated_by:
        :return: InlineResponse204
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs["_return_http_data_only"] = True
        if kwargs.get("async_req"):
            return self.platform_connection_destroy_with_http_info(
                body, **kwargs
            )  # noqa: E501
        else:
            (data) = self.platform_connection_destroy_with_http_info(
                body, **kwargs
            )  # noqa: E501
            return data

    def platform_connection_destroy_with_http_info(self, body, **kwargs):  # noqa: E501
        """platform_connection_destroy  # noqa: E501

        Deletes `connections` by supplied pairs of `platform agents`.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_connection_destroy_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param list[AgentsPairObject] body: (required)
        :param NetworkGenesisType network_updated_by:
        :return: InlineResponse204
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ["body", "network_updated_by"]  # noqa: E501
        all_params.append("async_req")
        all_params.append("_return_http_data_only")
        all_params.append("_preload_content")
        all_params.append("_request_timeout")

        params = locals()
        for key, val in six.iteritems(params["kwargs"]):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method platform_connection_destroy" % key
                )
            params[key] = val
        del params["kwargs"]
        # verify the required parameter 'body' is set
        if "body" not in params or params["body"] is None:
            raise ValueError(
                "Missing the required parameter `body` when calling `platform_connection_destroy`"
            )  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []
        if "network_updated_by" in params:
            query_params.append(
                ("network-updated-by", params["network_updated_by"])
            )  # noqa: E501

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if "body" in params:
            body_params = params["body"]
        # 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"]
        )  # noqa: E501

        # Authentication setting
        auth_settings = ["jwt"]  # noqa: E501

        return self.api_client.call_api(
            "/api/platform/connections/remove",
            "POST",
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type="InlineResponse204",  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get("async_req"),
            _return_http_data_only=params.get("_return_http_data_only"),
            _preload_content=params.get("_preload_content", True),
            _request_timeout=params.get("_request_timeout"),
            collection_formats=collection_formats,
        )

    def platform_connection_destroy_deprecated(
        self, connection_id, **kwargs
    ):  # noqa: E501
        """platform_connection_destroy_deprecated  # noqa: E501

        Removes agent pair (agent1, agent2) connections (PUBLIC, SDN{1,2,3}).  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_connection_destroy_deprecated(connection_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param IdNumber connection_id: (required)
        :param NetworkGenesisType network_updated_by:
        :return: InlineResponse204
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs["_return_http_data_only"] = True
        if kwargs.get("async_req"):
            return self.platform_connection_destroy_deprecated_with_http_info(
                connection_id, **kwargs
            )  # noqa: E501
        else:
            (data) = self.platform_connection_destroy_deprecated_with_http_info(
                connection_id, **kwargs
            )  # noqa: E501
            return data

    def platform_connection_destroy_deprecated_with_http_info(
        self, connection_id, **kwargs
    ):  # noqa: E501
        """platform_connection_destroy_deprecated  # noqa: E501

        Removes agent pair (agent1, agent2) connections (PUBLIC, SDN{1,2,3}).  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_connection_destroy_deprecated_with_http_info(connection_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param IdNumber connection_id: (required)
        :param NetworkGenesisType network_updated_by:
        :return: InlineResponse204
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ["connection_id", "network_updated_by"]  # noqa: E501
        all_params.append("async_req")
        all_params.append("_return_http_data_only")
        all_params.append("_preload_content")
        all_params.append("_request_timeout")

        params = locals()
        for key, val in six.iteritems(params["kwargs"]):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method platform_connection_destroy_deprecated" % key
                )
            params[key] = val
        del params["kwargs"]
        # verify the required parameter 'connection_id' is set
        if "connection_id" not in params or params["connection_id"] is None:
            raise ValueError(
                "Missing the required parameter `connection_id` when calling `platform_connection_destroy_deprecated`"
            )  # noqa: E501

        collection_formats = {}

        path_params = {}
        if "connection_id" in params:
            path_params["connection_id"] = params["connection_id"]  # noqa: E501

        query_params = []
        if "network_updated_by" in params:
            query_params.append(
                ("network-updated-by", params["network_updated_by"])
            )  # 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 = ["jwt"]  # noqa: E501

        return self.api_client.call_api(
            "/api/platform/connections/{connection_id}",
            "DELETE",
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type="InlineResponse204",  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get("async_req"),
            _return_http_data_only=params.get("_return_http_data_only"),
            _preload_content=params.get("_preload_content", True),
            _request_timeout=params.get("_request_timeout"),
            collection_formats=collection_formats,
        )

    def platform_connection_index(self, **kwargs):  # noqa: E501
        """platform_connection_index  # noqa: E501

        Retrieves connections.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_connection_index(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SkipNumber skip:
        :param TakeNumber take:
        :param OrderString order: string: \"ASC\" | \"DESC\"
        :param WhereString filter: id|name: string, example: \"1\" or \"name\", connectionId: string, example: \"1\", name: exact agent name, example: \"name1\", agent_ids[]: array of agent ids, example: \"1;2;3\", statuses[]: array of statuses, one of PENDING, WARNING, ERROR, CONNECTED, OFFLINE, example: \"OFFLINE;ERROR;WARNING\", networks[]: array of networks ids, example: \"1;2;3\", providers[]: array of providers ids, example: \"1;2;3\", agent_connection_updated_at_from: date from which connection was last modified, agent_connection_updated_at_to: date to which connection was last modified
        :param ShowSdnConnections show_sdn_connections:
        :param bool load_relations:
        :return: PlatformResponseAgentConnectionObjectArray_
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs["_return_http_data_only"] = True
        if kwargs.get("async_req"):
            return self.platform_connection_index_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.platform_connection_index_with_http_info(
                **kwargs
            )  # noqa: E501
            return data

    def platform_connection_index_with_http_info(self, **kwargs):  # noqa: E501
        """platform_connection_index  # noqa: E501

        Retrieves connections.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_connection_index_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SkipNumber skip:
        :param TakeNumber take:
        :param OrderString order: string: \"ASC\" | \"DESC\"
        :param WhereString filter: id|name: string, example: \"1\" or \"name\", connectionId: string, example: \"1\", name: exact agent name, example: \"name1\", agent_ids[]: array of agent ids, example: \"1;2;3\", statuses[]: array of statuses, one of PENDING, WARNING, ERROR, CONNECTED, OFFLINE, example: \"OFFLINE;ERROR;WARNING\", networks[]: array of networks ids, example: \"1;2;3\", providers[]: array of providers ids, example: \"1;2;3\", agent_connection_updated_at_from: date from which connection was last modified, agent_connection_updated_at_to: date to which connection was last modified
        :param ShowSdnConnections show_sdn_connections:
        :param bool load_relations:
        :return: PlatformResponseAgentConnectionObjectArray_
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = [
            "skip",
            "take",
            "order",
            "filter",
            "show_sdn_connections",
            "load_relations",
        ]  # noqa: E501
        all_params.append("async_req")
        all_params.append("_return_http_data_only")
        all_params.append("_preload_content")
        all_params.append("_request_timeout")

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

        collection_formats = {}

        path_params = {}

        query_params = []
        if "skip" in params:
            query_params.append(("skip", params["skip"]))  # noqa: E501
        if "take" in params:
            query_params.append(("take", params["take"]))  # noqa: E501
        if "order" in params:
            query_params.append(("order", params["order"]))  # noqa: E501
        if "filter" in params:
            query_params.append(("filter", params["filter"]))  # noqa: E501
        if "show_sdn_connections" in params:
            query_params.append(
                ("show-sdn-connections", params["show_sdn_connections"])
            )  # noqa: E501
        if "load_relations" in params:
            query_params.append(
                ("load-relations", params["load_relations"])
            )  # 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 = ["jwt"]  # noqa: E501

        return self.api_client.call_api(
            "/api/platform/connections",
            "GET",
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type="PlatformResponseAgentConnectionObjectArray_",  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get("async_req"),
            _return_http_data_only=params.get("_return_http_data_only"),
            _preload_content=params.get("_preload_content", True),
            _request_timeout=params.get("_request_timeout"),
            collection_formats=collection_formats,
        )

    def platform_connection_service_show(self, connection_ids, **kwargs):  # noqa: E501
        """platform_connection_service_show  # noqa: E501

        Retrieves connection services  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_connection_service_show(connection_ids, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param list[float] connection_ids: (required)
        :return: PlatformResponseAgentConnectionObjectArray_
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs["_return_http_data_only"] = True
        if kwargs.get("async_req"):
            return self.platform_connection_service_show_with_http_info(
                connection_ids, **kwargs
            )  # noqa: E501
        else:
            (data) = self.platform_connection_service_show_with_http_info(
                connection_ids, **kwargs
            )  # noqa: E501
            return data

    def platform_connection_service_show_with_http_info(
        self, connection_ids, **kwargs
    ):  # noqa: E501
        """platform_connection_service_show  # noqa: E501

        Retrieves connection services  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_connection_service_show_with_http_info(connection_ids, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param list[float] connection_ids: (required)
        :return: PlatformResponseAgentConnectionObjectArray_
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ["connection_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")

        params = locals()
        for key, val in six.iteritems(params["kwargs"]):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method platform_connection_service_show" % key
                )
            params[key] = val
        del params["kwargs"]
        # verify the required parameter 'connection_ids' is set
        if "connection_ids" not in params or params["connection_ids"] is None:
            raise ValueError(
                "Missing the required parameter `connection_ids` when calling `platform_connection_service_show`"
            )  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []
        if "connection_ids" in params:
            query_params.append(
                ("connection-ids", params["connection_ids"])
            )  # noqa: E501
            collection_formats["connection-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 = ["jwt"]  # noqa: E501

        return self.api_client.call_api(
            "/api/platform/connection-services",
            "GET",
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type="PlatformResponseAgentConnectionObjectArray_",  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get("async_req"),
            _return_http_data_only=params.get("_return_http_data_only"),
            _preload_content=params.get("_preload_content", True),
            _request_timeout=params.get("_request_timeout"),
            collection_formats=collection_formats,
        )

    def platform_connection_service_update(self, body, **kwargs):  # noqa: E501
        """platform_connection_service_update  # noqa: E501

        Updates agent connection services ips  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_connection_service_update(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param dict(str, object) body: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs["_return_http_data_only"] = True
        if kwargs.get("async_req"):
            return self.platform_connection_service_update_with_http_info(
                body, **kwargs
            )  # noqa: E501
        else:
            (data) = self.platform_connection_service_update_with_http_info(
                body, **kwargs
            )  # noqa: E501
            return data

    def platform_connection_service_update_with_http_info(
        self, body, **kwargs
    ):  # noqa: E501
        """platform_connection_service_update  # noqa: E501

        Updates agent connection services ips  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_connection_service_update_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param dict(str, object) body: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ["body"]  # noqa: E501
        all_params.append("async_req")
        all_params.append("_return_http_data_only")
        all_params.append("_preload_content")
        all_params.append("_request_timeout")

        params = locals()
        for key, val in six.iteritems(params["kwargs"]):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method platform_connection_service_update" % key
                )
            params[key] = val
        del params["kwargs"]
        # verify the required parameter 'body' is set
        if "body" not in params or params["body"] is None:
            raise ValueError(
                "Missing the required parameter `body` when calling `platform_connection_service_update`"
            )  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if "body" in params:
            body_params = params["body"]
        # HTTP header `Content-Type`
        header_params[
            "Content-Type"
        ] = self.api_client.select_header_content_type(  # noqa: E501
            ["application/json"]
        )  # noqa: E501

        # Authentication setting
        auth_settings = ["jwt"]  # noqa: E501

        return self.api_client.call_api(
            "/api/platform/connection-services",
            "POST",
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get("async_req"),
            _return_http_data_only=params.get("_return_http_data_only"),
            _preload_content=params.get("_preload_content", True),
            _request_timeout=params.get("_request_timeout"),
            collection_formats=collection_formats,
        )

    def platform_connection_subnet_destroy(self, body, **kwargs):  # noqa: E501
        """platform_connection_subnet_destroy  # noqa: E501

        Deletes agent connection services/subnets.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_connection_subnet_destroy(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param dict(str, object) body: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs["_return_http_data_only"] = True
        if kwargs.get("async_req"):
            return self.platform_connection_subnet_destroy_with_http_info(
                body, **kwargs
            )  # noqa: E501
        else:
            (data) = self.platform_connection_subnet_destroy_with_http_info(
                body, **kwargs
            )  # noqa: E501
            return data

    def platform_connection_subnet_destroy_with_http_info(
        self, body, **kwargs
    ):  # noqa: E501
        """platform_connection_subnet_destroy  # noqa: E501

        Deletes agent connection services/subnets.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_connection_subnet_destroy_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param dict(str, object) body: (required)
        :return: None
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ["body"]  # noqa: E501
        all_params.append("async_req")
        all_params.append("_return_http_data_only")
        all_params.append("_preload_content")
        all_params.append("_request_timeout")

        params = locals()
        for key, val in six.iteritems(params["kwargs"]):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method platform_connection_subnet_destroy" % key
                )
            params[key] = val
        del params["kwargs"]
        # verify the required parameter 'body' is set
        if "body" not in params or params["body"] is None:
            raise ValueError(
                "Missing the required parameter `body` when calling `platform_connection_subnet_destroy`"
            )  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if "body" in params:
            body_params = params["body"]
        # HTTP header `Content-Type`
        header_params[
            "Content-Type"
        ] = self.api_client.select_header_content_type(  # noqa: E501
            ["application/json"]
        )  # noqa: E501

        # Authentication setting
        auth_settings = ["jwt"]  # noqa: E501

        return self.api_client.call_api(
            "/api/platform/connection-services-delete",
            "POST",
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type=None,  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get("async_req"),
            _return_http_data_only=params.get("_return_http_data_only"),
            _preload_content=params.get("_preload_content", True),
            _request_timeout=params.get("_request_timeout"),
            collection_formats=collection_formats,
        )

    def platform_logs_read_timestamp(self, body, **kwargs):  # noqa: E501
        """platform_logs_read_timestamp  # noqa: E501

        Save last logs read timestamp.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_logs_read_timestamp(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param list[LogsReadTimestampObject] body: (required)
        :return: InlineResponse204
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs["_return_http_data_only"] = True
        if kwargs.get("async_req"):
            return self.platform_logs_read_timestamp_with_http_info(
                body, **kwargs
            )  # noqa: E501
        else:
            (data) = self.platform_logs_read_timestamp_with_http_info(
                body, **kwargs
            )  # noqa: E501
            return data

    def platform_logs_read_timestamp_with_http_info(self, body, **kwargs):  # noqa: E501
        """platform_logs_read_timestamp  # noqa: E501

        Save last logs read timestamp.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_logs_read_timestamp_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param list[LogsReadTimestampObject] body: (required)
        :return: InlineResponse204
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ["body"]  # noqa: E501
        all_params.append("async_req")
        all_params.append("_return_http_data_only")
        all_params.append("_preload_content")
        all_params.append("_request_timeout")

        params = locals()
        for key, val in six.iteritems(params["kwargs"]):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method platform_logs_read_timestamp" % key
                )
            params[key] = val
        del params["kwargs"]
        # verify the required parameter 'body' is set
        if "body" not in params or params["body"] is None:
            raise ValueError(
                "Missing the required parameter `body` when calling `platform_logs_read_timestamp`"
            )  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if "body" in params:
            body_params = params["body"]
        # 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"]
        )  # noqa: E501

        # Authentication setting
        auth_settings = ["jwt"]  # noqa: E501

        return self.api_client.call_api(
            "/api/platform/logs-reads-timestamp",
            "POST",
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type="InlineResponse204",  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get("async_req"),
            _return_http_data_only=params.get("_return_http_data_only"),
            _preload_content=params.get("_preload_content", True),
            _request_timeout=params.get("_request_timeout"),
            collection_formats=collection_formats,
        )

    def platform_network_agent_create(self, body, network_id, **kwargs):  # noqa: E501
        """platform_network_agent_create  # noqa: E501

        Adds agents to network without modifying connections.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_network_agent_create(body, network_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param list[NetworkAgentPayload] body: (required)
        :param IdNumber network_id: (required)
        :return: InlineResponse204
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs["_return_http_data_only"] = True
        if kwargs.get("async_req"):
            return self.platform_network_agent_create_with_http_info(
                body, network_id, **kwargs
            )  # noqa: E501
        else:
            (data) = self.platform_network_agent_create_with_http_info(
                body, network_id, **kwargs
            )  # noqa: E501
            return data

    def platform_network_agent_create_with_http_info(
        self, body, network_id, **kwargs
    ):  # noqa: E501
        """platform_network_agent_create  # noqa: E501

        Adds agents to network without modifying connections.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_network_agent_create_with_http_info(body, network_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param list[NetworkAgentPayload] body: (required)
        :param IdNumber network_id: (required)
        :return: InlineResponse204
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ["body", "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")

        params = locals()
        for key, val in six.iteritems(params["kwargs"]):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method platform_network_agent_create" % key
                )
            params[key] = val
        del params["kwargs"]
        # verify the required parameter 'body' is set
        if "body" not in params or params["body"] is None:
            raise ValueError(
                "Missing the required parameter `body` when calling `platform_network_agent_create`"
            )  # noqa: E501
        # verify the required parameter 'network_id' is set
        if "network_id" not in params or params["network_id"] is None:
            raise ValueError(
                "Missing the required parameter `network_id` when calling `platform_network_agent_create`"
            )  # noqa: E501

        collection_formats = {}

        path_params = {}
        if "network_id" in params:
            path_params["network_id"] = params["network_id"]  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if "body" in params:
            body_params = params["body"]
        # 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"]
        )  # noqa: E501

        # Authentication setting
        auth_settings = ["jwt"]  # noqa: E501

        return self.api_client.call_api(
            "/api/platform/network/{network_id}/agents/add",
            "POST",
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type="InlineResponse204",  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get("async_req"),
            _return_http_data_only=params.get("_return_http_data_only"),
            _preload_content=params.get("_preload_content", True),
            _request_timeout=params.get("_request_timeout"),
            collection_formats=collection_formats,
        )

    def platform_network_agent_create_deprecated(
        self, body, network_id, **kwargs
    ):  # noqa: E501
        """platform_network_agent_create_deprecated  # noqa: E501

        Adds `platform agents` to `network` view. Does not modify `connections`.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_network_agent_create_deprecated(body, network_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param list[NetworkAgentPayload] body: (required)
        :param IdNumber network_id: (required)
        :return: InlineResponse204
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs["_return_http_data_only"] = True
        if kwargs.get("async_req"):
            return self.platform_network_agent_create_deprecated_with_http_info(
                body, network_id, **kwargs
            )  # noqa: E501
        else:
            (data) = self.platform_network_agent_create_deprecated_with_http_info(
                body, network_id, **kwargs
            )  # noqa: E501
            return data

    def platform_network_agent_create_deprecated_with_http_info(
        self, body, network_id, **kwargs
    ):  # noqa: E501
        """platform_network_agent_create_deprecated  # noqa: E501

        Adds `platform agents` to `network` view. Does not modify `connections`.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_network_agent_create_deprecated_with_http_info(body, network_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param list[NetworkAgentPayload] body: (required)
        :param IdNumber network_id: (required)
        :return: InlineResponse204
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ["body", "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")

        params = locals()
        for key, val in six.iteritems(params["kwargs"]):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method platform_network_agent_create_deprecated" % key
                )
            params[key] = val
        del params["kwargs"]
        # verify the required parameter 'body' is set
        if "body" not in params or params["body"] is None:
            raise ValueError(
                "Missing the required parameter `body` when calling `platform_network_agent_create_deprecated`"
            )  # noqa: E501
        # verify the required parameter 'network_id' is set
        if "network_id" not in params or params["network_id"] is None:
            raise ValueError(
                "Missing the required parameter `network_id` when calling `platform_network_agent_create_deprecated`"
            )  # noqa: E501

        collection_formats = {}

        path_params = {}
        if "network_id" in params:
            path_params["network_id"] = params["network_id"]  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if "body" in params:
            body_params = params["body"]
        # 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"]
        )  # noqa: E501

        # Authentication setting
        auth_settings = ["jwt"]  # noqa: E501

        return self.api_client.call_api(
            "/api/platform/network/{network_id}/agents",
            "POST",
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type="InlineResponse204",  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get("async_req"),
            _return_http_data_only=params.get("_return_http_data_only"),
            _preload_content=params.get("_preload_content", True),
            _request_timeout=params.get("_request_timeout"),
            collection_formats=collection_formats,
        )

    def platform_network_agent_destroy(
        self, network_id, agent_id, **kwargs
    ):  # noqa: E501
        """platform_network_agent_destroy  # noqa: E501

        Removes agent from network view and connections associated with it.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_network_agent_destroy(network_id, agent_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param IdNumber network_id: (required)
        :param IdNumber agent_id: (required)
        :return: InlineResponse204
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs["_return_http_data_only"] = True
        if kwargs.get("async_req"):
            return self.platform_network_agent_destroy_with_http_info(
                network_id, agent_id, **kwargs
            )  # noqa: E501
        else:
            (data) = self.platform_network_agent_destroy_with_http_info(
                network_id, agent_id, **kwargs
            )  # noqa: E501
            return data

    def platform_network_agent_destroy_with_http_info(
        self, network_id, agent_id, **kwargs
    ):  # noqa: E501
        """platform_network_agent_destroy  # noqa: E501

        Removes agent from network view and connections associated with it.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_network_agent_destroy_with_http_info(network_id, agent_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param IdNumber network_id: (required)
        :param IdNumber agent_id: (required)
        :return: InlineResponse204
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ["network_id", "agent_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")

        params = locals()
        for key, val in six.iteritems(params["kwargs"]):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method platform_network_agent_destroy" % key
                )
            params[key] = val
        del params["kwargs"]
        # verify the required parameter 'network_id' is set
        if "network_id" not in params or params["network_id"] is None:
            raise ValueError(
                "Missing the required parameter `network_id` when calling `platform_network_agent_destroy`"
            )  # noqa: E501
        # verify the required parameter 'agent_id' is set
        if "agent_id" not in params or params["agent_id"] is None:
            raise ValueError(
                "Missing the required parameter `agent_id` when calling `platform_network_agent_destroy`"
            )  # noqa: E501

        collection_formats = {}

        path_params = {}
        if "network_id" in params:
            path_params["network_id"] = params["network_id"]  # noqa: E501
        if "agent_id" in params:
            path_params["agent_id"] = params["agent_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 = ["jwt"]  # noqa: E501

        return self.api_client.call_api(
            "/api/platform/networks/{network_id}/agents/{agent_id}",
            "DELETE",
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type="InlineResponse204",  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get("async_req"),
            _return_http_data_only=params.get("_return_http_data_only"),
            _preload_content=params.get("_preload_content", True),
            _request_timeout=params.get("_request_timeout"),
            collection_formats=collection_formats,
        )

    def platform_network_agent_group_create(
        self, network_id, group_name, **kwargs
    ):  # noqa: E501
        """platform_network_agent_group_create  # noqa: E501

        Creates agent group relation.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_network_agent_group_create(network_id, group_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param IdNumber network_id: (required)
        :param DefaultString group_name: (required)
        :param list[float] body:
        :return: InlineResponse204
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs["_return_http_data_only"] = True
        if kwargs.get("async_req"):
            return self.platform_network_agent_group_create_with_http_info(
                network_id, group_name, **kwargs
            )  # noqa: E501
        else:
            (data) = self.platform_network_agent_group_create_with_http_info(
                network_id, group_name, **kwargs
            )  # noqa: E501
            return data

    def platform_network_agent_group_create_with_http_info(
        self, network_id, group_name, **kwargs
    ):  # noqa: E501
        """platform_network_agent_group_create  # noqa: E501

        Creates agent group relation.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_network_agent_group_create_with_http_info(network_id, group_name, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param IdNumber network_id: (required)
        :param DefaultString group_name: (required)
        :param list[float] body:
        :return: InlineResponse204
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ["network_id", "group_name", "body"]  # noqa: E501
        all_params.append("async_req")
        all_params.append("_return_http_data_only")
        all_params.append("_preload_content")
        all_params.append("_request_timeout")

        params = locals()
        for key, val in six.iteritems(params["kwargs"]):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method platform_network_agent_group_create" % key
                )
            params[key] = val
        del params["kwargs"]
        # verify the required parameter 'network_id' is set
        if "network_id" not in params or params["network_id"] is None:
            raise ValueError(
                "Missing the required parameter `network_id` when calling `platform_network_agent_group_create`"
            )  # noqa: E501
        # verify the required parameter 'group_name' is set
        if "group_name" not in params or params["group_name"] is None:
            raise ValueError(
                "Missing the required parameter `group_name` when calling `platform_network_agent_group_create`"
            )  # noqa: E501

        collection_formats = {}

        path_params = {}
        if "network_id" in params:
            path_params["network_id"] = params["network_id"]  # noqa: E501
        if "group_name" in params:
            path_params["group_name"] = params["group_name"]  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if "body" in params:
            body_params = params["body"]
        # 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"]
        )  # noqa: E501

        # Authentication setting
        auth_settings = ["jwt"]  # noqa: E501

        return self.api_client.call_api(
            "/api/platform/network/{network_id}/agent-groups/{group_name}",
            "POST",
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type="InlineResponse204",  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get("async_req"),
            _return_http_data_only=params.get("_return_http_data_only"),
            _preload_content=params.get("_preload_content", True),
            _request_timeout=params.get("_request_timeout"),
            collection_formats=collection_formats,
        )

    def platform_network_agent_remove(self, body, network_id, **kwargs):  # noqa: E501
        """platform_network_agent_remove  # noqa: E501

        Remove agents from network view without unconfiguring connections.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_network_agent_remove(body, network_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param list[float] body: (required)
        :param IdNumber network_id: (required)
        :return: InlineResponse204
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs["_return_http_data_only"] = True
        if kwargs.get("async_req"):
            return self.platform_network_agent_remove_with_http_info(
                body, network_id, **kwargs
            )  # noqa: E501
        else:
            (data) = self.platform_network_agent_remove_with_http_info(
                body, network_id, **kwargs
            )  # noqa: E501
            return data

    def platform_network_agent_remove_with_http_info(
        self, body, network_id, **kwargs
    ):  # noqa: E501
        """platform_network_agent_remove  # noqa: E501

        Remove agents from network view without unconfiguring connections.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_network_agent_remove_with_http_info(body, network_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param list[float] body: (required)
        :param IdNumber network_id: (required)
        :return: InlineResponse204
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ["body", "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")

        params = locals()
        for key, val in six.iteritems(params["kwargs"]):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method platform_network_agent_remove" % key
                )
            params[key] = val
        del params["kwargs"]
        # verify the required parameter 'body' is set
        if "body" not in params or params["body"] is None:
            raise ValueError(
                "Missing the required parameter `body` when calling `platform_network_agent_remove`"
            )  # noqa: E501
        # verify the required parameter 'network_id' is set
        if "network_id" not in params or params["network_id"] is None:
            raise ValueError(
                "Missing the required parameter `network_id` when calling `platform_network_agent_remove`"
            )  # noqa: E501

        collection_formats = {}

        path_params = {}
        if "network_id" in params:
            path_params["network_id"] = params["network_id"]  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if "body" in params:
            body_params = params["body"]
        # 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"]
        )  # noqa: E501

        # Authentication setting
        auth_settings = ["jwt"]  # noqa: E501

        return self.api_client.call_api(
            "/api/platform/networks/{network_id}/agents/remove",
            "POST",
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type="InlineResponse204",  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get("async_req"),
            _return_http_data_only=params.get("_return_http_data_only"),
            _preload_content=params.get("_preload_content", True),
            _request_timeout=params.get("_request_timeout"),
            collection_formats=collection_formats,
        )

    def platform_network_agent_remove_deprecated(
        self, body, network_id, **kwargs
    ):  # noqa: E501
        """platform_network_agent_remove_deprecated  # noqa: E501

        Remove `platform agents` from `network` view. Does not modify `connections`.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_network_agent_remove_deprecated(body, network_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param list[float] body: (required)
        :param IdNumber network_id: (required)
        :return: InlineResponse204
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs["_return_http_data_only"] = True
        if kwargs.get("async_req"):
            return self.platform_network_agent_remove_deprecated_with_http_info(
                body, network_id, **kwargs
            )  # noqa: E501
        else:
            (data) = self.platform_network_agent_remove_deprecated_with_http_info(
                body, network_id, **kwargs
            )  # noqa: E501
            return data

    def platform_network_agent_remove_deprecated_with_http_info(
        self, body, network_id, **kwargs
    ):  # noqa: E501
        """platform_network_agent_remove_deprecated  # noqa: E501

        Remove `platform agents` from `network` view. Does not modify `connections`.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_network_agent_remove_deprecated_with_http_info(body, network_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param list[float] body: (required)
        :param IdNumber network_id: (required)
        :return: InlineResponse204
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ["body", "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")

        params = locals()
        for key, val in six.iteritems(params["kwargs"]):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method platform_network_agent_remove_deprecated" % key
                )
            params[key] = val
        del params["kwargs"]
        # verify the required parameter 'body' is set
        if "body" not in params or params["body"] is None:
            raise ValueError(
                "Missing the required parameter `body` when calling `platform_network_agent_remove_deprecated`"
            )  # noqa: E501
        # verify the required parameter 'network_id' is set
        if "network_id" not in params or params["network_id"] is None:
            raise ValueError(
                "Missing the required parameter `network_id` when calling `platform_network_agent_remove_deprecated`"
            )  # noqa: E501

        collection_formats = {}

        path_params = {}
        if "network_id" in params:
            path_params["network_id"] = params["network_id"]  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if "body" in params:
            body_params = params["body"]
        # 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"]
        )  # noqa: E501

        # Authentication setting
        auth_settings = ["jwt"]  # noqa: E501

        return self.api_client.call_api(
            "/api/platform/networks/{network_id}/agents",
            "DELETE",
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type="InlineResponse204",  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get("async_req"),
            _return_http_data_only=params.get("_return_http_data_only"),
            _preload_content=params.get("_preload_content", True),
            _request_timeout=params.get("_request_timeout"),
            collection_formats=collection_formats,
        )

    def platform_network_create(self, body, **kwargs):  # noqa: E501
        """platform_network_create  # noqa: E501

        Creates 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.platform_network_create(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param dict(str, object) body: (required)
        :return: PlatformResponseNetworkObject_
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs["_return_http_data_only"] = True
        if kwargs.get("async_req"):
            return self.platform_network_create_with_http_info(
                body, **kwargs
            )  # noqa: E501
        else:
            (data) = self.platform_network_create_with_http_info(
                body, **kwargs
            )  # noqa: E501
            return data

    def platform_network_create_with_http_info(self, body, **kwargs):  # noqa: E501
        """platform_network_create  # noqa: E501

        Creates 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.platform_network_create_with_http_info(body, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param dict(str, object) body: (required)
        :return: PlatformResponseNetworkObject_
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ["body"]  # noqa: E501
        all_params.append("async_req")
        all_params.append("_return_http_data_only")
        all_params.append("_preload_content")
        all_params.append("_request_timeout")

        params = locals()
        for key, val in six.iteritems(params["kwargs"]):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method platform_network_create" % key
                )
            params[key] = val
        del params["kwargs"]
        # verify the required parameter 'body' is set
        if "body" not in params or params["body"] is None:
            raise ValueError(
                "Missing the required parameter `body` when calling `platform_network_create`"
            )  # noqa: E501

        collection_formats = {}

        path_params = {}

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if "body" in params:
            body_params = params["body"]
        # 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"]
        )  # noqa: E501

        # Authentication setting
        auth_settings = ["jwt"]  # noqa: E501

        return self.api_client.call_api(
            "/api/platform/networks",
            "POST",
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type="PlatformResponseNetworkObject_",  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get("async_req"),
            _return_http_data_only=params.get("_return_http_data_only"),
            _preload_content=params.get("_preload_content", True),
            _request_timeout=params.get("_request_timeout"),
            collection_formats=collection_formats,
        )

    def platform_network_destroy(self, network_id, **kwargs):  # noqa: E501
        """platform_network_destroy  # noqa: E501

        Deletes `network`. Does not modify `connections`.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_network_destroy(network_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param IdNumber network_id: (required)
        :return: InlineResponse204
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs["_return_http_data_only"] = True
        if kwargs.get("async_req"):
            return self.platform_network_destroy_with_http_info(
                network_id, **kwargs
            )  # noqa: E501
        else:
            (data) = self.platform_network_destroy_with_http_info(
                network_id, **kwargs
            )  # noqa: E501
            return data

    def platform_network_destroy_with_http_info(
        self, network_id, **kwargs
    ):  # noqa: E501
        """platform_network_destroy  # noqa: E501

        Deletes `network`. Does not modify `connections`.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_network_destroy_with_http_info(network_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param IdNumber network_id: (required)
        :return: InlineResponse204
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ["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")

        params = locals()
        for key, val in six.iteritems(params["kwargs"]):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method platform_network_destroy" % key
                )
            params[key] = val
        del params["kwargs"]
        # verify the required parameter 'network_id' is set
        if "network_id" not in params or params["network_id"] is None:
            raise ValueError(
                "Missing the required parameter `network_id` when calling `platform_network_destroy`"
            )  # noqa: E501

        collection_formats = {}

        path_params = {}
        if "network_id" in params:
            path_params["network_id"] = 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 = ["jwt"]  # noqa: E501

        return self.api_client.call_api(
            "/api/platform/networks/{network_id}",
            "DELETE",
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type="InlineResponse204",  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get("async_req"),
            _return_http_data_only=params.get("_return_http_data_only"),
            _preload_content=params.get("_preload_content", True),
            _request_timeout=params.get("_request_timeout"),
            collection_formats=collection_formats,
        )

    def platform_network_index(self, **kwargs):  # noqa: E501
        """platform_network_index  # noqa: E501

        Retrieves networks.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_network_index(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SkipNumber skip:
        :param TakeNumber take:
        :param OrderString order: string: \"ASC\" | \"DESC\"
        :param WhereString filter: id|name: string, name: string,
        :return: PlatformResponseNetworkObjectArray_
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs["_return_http_data_only"] = True
        if kwargs.get("async_req"):
            return self.platform_network_index_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.platform_network_index_with_http_info(**kwargs)  # noqa: E501
            return data

    def platform_network_index_with_http_info(self, **kwargs):  # noqa: E501
        """platform_network_index  # noqa: E501

        Retrieves networks.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_network_index_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param SkipNumber skip:
        :param TakeNumber take:
        :param OrderString order: string: \"ASC\" | \"DESC\"
        :param WhereString filter: id|name: string, name: string,
        :return: PlatformResponseNetworkObjectArray_
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ["skip", "take", "order", "filter"]  # noqa: E501
        all_params.append("async_req")
        all_params.append("_return_http_data_only")
        all_params.append("_preload_content")
        all_params.append("_request_timeout")

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

        collection_formats = {}

        path_params = {}

        query_params = []
        if "skip" in params:
            query_params.append(("skip", params["skip"]))  # noqa: E501
        if "take" in params:
            query_params.append(("take", params["take"]))  # noqa: E501
        if "order" in params:
            query_params.append(("order", params["order"]))  # noqa: E501
        if "filter" in params:
            query_params.append(("filter", params["filter"]))  # 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 = ["jwt"]  # noqa: E501

        return self.api_client.call_api(
            "/api/platform/networks",
            "GET",
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type="PlatformResponseNetworkObjectArray_",  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get("async_req"),
            _return_http_data_only=params.get("_return_http_data_only"),
            _preload_content=params.get("_preload_content", True),
            _request_timeout=params.get("_request_timeout"),
            collection_formats=collection_formats,
        )

    def platform_network_info(self, network_id, **kwargs):  # noqa: E501
        """platform_network_info  # noqa: E501

        Get network info.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_network_info(network_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param IdNumber network_id: (required)
        :return: PlatformResponseNetworkInfoObject_
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs["_return_http_data_only"] = True
        if kwargs.get("async_req"):
            return self.platform_network_info_with_http_info(
                network_id, **kwargs
            )  # noqa: E501
        else:
            (data) = self.platform_network_info_with_http_info(
                network_id, **kwargs
            )  # noqa: E501
            return data

    def platform_network_info_with_http_info(self, network_id, **kwargs):  # noqa: E501
        """platform_network_info  # noqa: E501

        Get network info.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_network_info_with_http_info(network_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param IdNumber network_id: (required)
        :return: PlatformResponseNetworkInfoObject_
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ["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")

        params = locals()
        for key, val in six.iteritems(params["kwargs"]):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method platform_network_info" % key
                )
            params[key] = val
        del params["kwargs"]
        # verify the required parameter 'network_id' is set
        if "network_id" not in params or params["network_id"] is None:
            raise ValueError(
                "Missing the required parameter `network_id` when calling `platform_network_info`"
            )  # noqa: E501

        collection_formats = {}

        path_params = {}
        if "network_id" in params:
            path_params["network_id"] = 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 = ["jwt"]  # noqa: E501

        return self.api_client.call_api(
            "/api/platform/network/{network_id}/info",
            "GET",
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type="PlatformResponseNetworkInfoObject_",  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get("async_req"),
            _return_http_data_only=params.get("_return_http_data_only"),
            _preload_content=params.get("_preload_content", True),
            _request_timeout=params.get("_request_timeout"),
            collection_formats=collection_formats,
        )

    def platform_network_network_agent_destroy_deprecated(
        self, body, network_id, **kwargs
    ):  # noqa: E501
        """platform_network_network_agent_destroy_deprecated  # noqa: E501

        Removes network agents.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_network_network_agent_destroy_deprecated(body, network_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param list[float] body: (required)
        :param IdNumber network_id: (required)
        :return: InlineResponse204
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs["_return_http_data_only"] = True
        if kwargs.get("async_req"):
            return (
                self.platform_network_network_agent_destroy_deprecated_with_http_info(
                    body, network_id, **kwargs
                )
            )  # noqa: E501
        else:
            (
                data
            ) = self.platform_network_network_agent_destroy_deprecated_with_http_info(
                body, network_id, **kwargs
            )  # noqa: E501
            return data

    def platform_network_network_agent_destroy_deprecated_with_http_info(
        self, body, network_id, **kwargs
    ):  # noqa: E501
        """platform_network_network_agent_destroy_deprecated  # noqa: E501

        Removes network agents.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_network_network_agent_destroy_deprecated_with_http_info(body, network_id, async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param list[float] body: (required)
        :param IdNumber network_id: (required)
        :return: InlineResponse204
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ["body", "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")

        params = locals()
        for key, val in six.iteritems(params["kwargs"]):
            if key not in all_params:
                raise TypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method platform_network_network_agent_destroy_deprecated" % key
                )
            params[key] = val
        del params["kwargs"]
        # verify the required parameter 'body' is set
        if "body" not in params or params["body"] is None:
            raise ValueError(
                "Missing the required parameter `body` when calling `platform_network_network_agent_destroy_deprecated`"
            )  # noqa: E501
        # verify the required parameter 'network_id' is set
        if "network_id" not in params or params["network_id"] is None:
            raise ValueError(
                "Missing the required parameter `network_id` when calling `platform_network_network_agent_destroy_deprecated`"
            )  # noqa: E501

        collection_formats = {}

        path_params = {}
        if "network_id" in params:
            path_params["network_id"] = params["network_id"]  # noqa: E501

        query_params = []

        header_params = {}

        form_params = []
        local_var_files = {}

        body_params = None
        if "body" in params:
            body_params = params["body"]
        # 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"]
        )  # noqa: E501

        # Authentication setting
        auth_settings = ["jwt"]  # noqa: E501

        return self.api_client.call_api(
            "/api/platform/network/{network_id}/agents/delete",
            "POST",
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type="InlineResponse204",  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get("async_req"),
            _return_http_data_only=params.get("_return_http_data_only"),
            _preload_content=params.get("_preload_content", True),
            _request_timeout=params.get("_request_timeout"),
            collection_formats=collection_formats,
        )

    def platform_network_topology(self, **kwargs):  # noqa: E501
        """platform_network_topology  # noqa: E501

        Retrieves networks topology.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_network_topology(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param IdNumber network_id:
        :return: PlatformResponseNetworkTopologyObjectArray_
                 If the method is called asynchronously,
                 returns the request thread.
        """
        kwargs["_return_http_data_only"] = True
        if kwargs.get("async_req"):
            return self.platform_network_topology_with_http_info(**kwargs)  # noqa: E501
        else:
            (data) = self.platform_network_topology_with_http_info(
                **kwargs
            )  # noqa: E501
            return data

    def platform_network_topology_with_http_info(self, **kwargs):  # noqa: E501
        """platform_network_topology  # noqa: E501

        Retrieves networks topology.  # noqa: E501
        This method makes a synchronous HTTP request by default. To make an
        asynchronous HTTP request, please pass async_req=True
        >>> thread = api.platform_network_topology_with_http_info(async_req=True)
        >>> result = thread.get()

        :param async_req bool
        :param IdNumber network_id:
        :return: PlatformResponseNetworkTopologyObjectArray_
                 If the method is called asynchronously,
                 returns the request thread.
        """

        all_params = ["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")

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

        collection_formats = {}

        path_params = {}

        query_params = []
        if "network_id" in params:
            query_params.append(("network_id", params["network_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 = ["jwt"]  # noqa: E501

        return self.api_client.call_api(
            "/api/platform/networks/topology",
            "GET",
            path_params,
            query_params,
            header_params,
            body=body_params,
            post_params=form_params,
            files=local_var_files,
            response_type="PlatformResponseNetworkTopologyObjectArray_",  # noqa: E501
            auth_settings=auth_settings,
            async_req=params.get("async_req"),
            _return_http_data_only=params.get("_return_http_data_only"),
            _preload_content=params.get("_preload_content", True),
            _request_timeout=params.get("_request_timeout"),
            collection_formats=collection_formats,
        )
