connection_api.py

# coding: utf-8

"""
    Aries Cloud Agent

    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)

    The version of the OpenAPI document: v0.9.0
    Generated by OpenAPI Generator (https://openapi-generator.tech)

    Do not edit the class manually.
"""  # noqa: E501


from typing import Dict, List, Optional, Tuple

from pydantic import Field, StrictBool, StrictStr, validate_call
from typing_extensions import Annotated

from aries_cloudcontroller.api_client import ApiClient
from aries_cloudcontroller.api_response import ApiResponse
from aries_cloudcontroller.exceptions import ApiTypeError
from aries_cloudcontroller.models.conn_record import ConnRecord
from aries_cloudcontroller.models.connection_list import ConnectionList
from aries_cloudcontroller.models.connection_metadata import ConnectionMetadata
from aries_cloudcontroller.models.connection_metadata_set_request import (
    ConnectionMetadataSetRequest,
)
from aries_cloudcontroller.models.connection_static_request import (
    ConnectionStaticRequest,
)
from aries_cloudcontroller.models.connection_static_result import ConnectionStaticResult
from aries_cloudcontroller.models.create_invitation_request import (
    CreateInvitationRequest,
)
from aries_cloudcontroller.models.endpoints_result import EndpointsResult
from aries_cloudcontroller.models.invitation_result import InvitationResult
from aries_cloudcontroller.models.receive_invitation_request import (
    ReceiveInvitationRequest,
)


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

    Do not edit the class manually.
    """

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

    @validate_call
    async def accept_invitation(
        self,
        conn_id: Annotated[StrictStr, Field(description="Connection identifier")],
        mediation_id: Annotated[
            Optional[StrictStr],
            Field(description="Identifier for active mediation record to be used"),
        ] = None,
        my_endpoint: Annotated[
            Optional[StrictStr], Field(description="My URL endpoint")
        ] = None,
        my_label: Annotated[
            Optional[StrictStr], Field(description="Label for connection")
        ] = None,
        **kwargs,
    ) -> ConnRecord:
        """Accept a stored connection invitation  # noqa: E501


        :param conn_id: Connection identifier (required)
        :type conn_id: str
        :param mediation_id: Identifier for active mediation record to be used
        :type mediation_id: str
        :param my_endpoint: My URL endpoint
        :type my_endpoint: str
        :param my_label: Label for connection
        :type my_label: str
        :param _request_timeout: timeout setting for this request.
               If one number provided, it will be total request
               timeout. It can also be a pair (tuple) of
               (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: ConnRecord
        """
        kwargs["_return_http_data_only"] = True
        if "_preload_content" in kwargs:
            message = "Error! Please call the accept_invitation_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data"  # noqa: E501
            raise ValueError(message)

        return await self.accept_invitation_with_http_info.raw_function(
            conn_id,
            mediation_id,
            my_endpoint,
            my_label,
            **kwargs,
        )

    @validate_call
    async def accept_invitation_with_http_info(
        self,
        conn_id: Annotated[StrictStr, Field(description="Connection identifier")],
        mediation_id: Annotated[
            Optional[StrictStr],
            Field(description="Identifier for active mediation record to be used"),
        ] = None,
        my_endpoint: Annotated[
            Optional[StrictStr], Field(description="My URL endpoint")
        ] = None,
        my_label: Annotated[
            Optional[StrictStr], Field(description="Label for connection")
        ] = None,
        **kwargs,
    ) -> ApiResponse:
        """Accept a stored connection invitation  # noqa: E501


        :param conn_id: Connection identifier (required)
        :type conn_id: str
        :param mediation_id: Identifier for active mediation record to be used
        :type mediation_id: str
        :param my_endpoint: My URL endpoint
        :type my_endpoint: str
        :param my_label: Label for connection
        :type my_label: str
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(ConnRecord, status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = ["conn_id", "mediation_id", "my_endpoint", "my_label"]
        _all_params.extend(
            [
                "_return_http_data_only",
                "_preload_content",
                "_request_timeout",
                "_request_auth",
                "_content_type",
                "_headers",
            ]
        )

        # validate the arguments
        for _key, _val in _params["kwargs"].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method accept_invitation" % _key
                )
            _params[_key] = _val
        del _params["kwargs"]

        _collection_formats: Dict[str, str] = {}

        # process the path parameters
        _path_params: Dict[str, str] = {}
        if _params["conn_id"] is not None:
            _path_params["conn_id"] = _params["conn_id"]

        # process the query parameters
        _query_params: List[Tuple[str, str]] = []
        if _params.get("mediation_id") is not None:  # noqa: E501
            _query_params.append(("mediation_id", _params["mediation_id"]))

        if _params.get("my_endpoint") is not None:  # noqa: E501
            _query_params.append(("my_endpoint", _params["my_endpoint"]))

        if _params.get("my_label") is not None:  # noqa: E501
            _query_params.append(("my_label", _params["my_label"]))

        # process the header parameters
        _header_params = dict(_params.get("_headers", {}))
        # process the form parameters
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[str, str] = {}
        # process the body parameter
        _body_params = None
        # set the HTTP header `Accept`
        _header_params["Accept"] = self.api_client.select_header_accept(
            ["application/json"]
        )  # noqa: E501

        # authentication setting
        _auth_settings: List[str] = ["AuthorizationHeader"]  # noqa: E501

        _response_types_map: Dict[str, Optional[str]] = {
            "200": "ConnRecord",
        }

        return await self.api_client.call_api(
            "/connections/{conn_id}/accept-invitation",
            "POST",
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            _return_http_data_only=_params.get("_return_http_data_only"),  # noqa: E501
            _preload_content=_params.get("_preload_content", True),
            _request_timeout=_params.get("_request_timeout"),
            collection_formats=_collection_formats,
            _request_auth=_params.get("_request_auth"),
        )

    @validate_call
    async def accept_request(
        self,
        conn_id: Annotated[StrictStr, Field(description="Connection identifier")],
        my_endpoint: Annotated[
            Optional[StrictStr], Field(description="My URL endpoint")
        ] = None,
        **kwargs,
    ) -> ConnRecord:
        """Accept a stored connection request  # noqa: E501


        :param conn_id: Connection identifier (required)
        :type conn_id: str
        :param my_endpoint: My URL endpoint
        :type my_endpoint: str
        :param _request_timeout: timeout setting for this request.
               If one number provided, it will be total request
               timeout. It can also be a pair (tuple) of
               (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: ConnRecord
        """
        kwargs["_return_http_data_only"] = True
        if "_preload_content" in kwargs:
            message = "Error! Please call the accept_request_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data"  # noqa: E501
            raise ValueError(message)

        return await self.accept_request_with_http_info.raw_function(
            conn_id,
            my_endpoint,
            **kwargs,
        )

    @validate_call
    async def accept_request_with_http_info(
        self,
        conn_id: Annotated[StrictStr, Field(description="Connection identifier")],
        my_endpoint: Annotated[
            Optional[StrictStr], Field(description="My URL endpoint")
        ] = None,
        **kwargs,
    ) -> ApiResponse:
        """Accept a stored connection request  # noqa: E501


        :param conn_id: Connection identifier (required)
        :type conn_id: str
        :param my_endpoint: My URL endpoint
        :type my_endpoint: str
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(ConnRecord, status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = ["conn_id", "my_endpoint"]
        _all_params.extend(
            [
                "_return_http_data_only",
                "_preload_content",
                "_request_timeout",
                "_request_auth",
                "_content_type",
                "_headers",
            ]
        )

        # validate the arguments
        for _key, _val in _params["kwargs"].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method accept_request" % _key
                )
            _params[_key] = _val
        del _params["kwargs"]

        _collection_formats: Dict[str, str] = {}

        # process the path parameters
        _path_params: Dict[str, str] = {}
        if _params["conn_id"] is not None:
            _path_params["conn_id"] = _params["conn_id"]

        # process the query parameters
        _query_params: List[Tuple[str, str]] = []
        if _params.get("my_endpoint") is not None:  # noqa: E501
            _query_params.append(("my_endpoint", _params["my_endpoint"]))

        # process the header parameters
        _header_params = dict(_params.get("_headers", {}))
        # process the form parameters
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[str, str] = {}
        # process the body parameter
        _body_params = None
        # set the HTTP header `Accept`
        _header_params["Accept"] = self.api_client.select_header_accept(
            ["application/json"]
        )  # noqa: E501

        # authentication setting
        _auth_settings: List[str] = ["AuthorizationHeader"]  # noqa: E501

        _response_types_map: Dict[str, Optional[str]] = {
            "200": "ConnRecord",
        }

        return await self.api_client.call_api(
            "/connections/{conn_id}/accept-request",
            "POST",
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            _return_http_data_only=_params.get("_return_http_data_only"),  # noqa: E501
            _preload_content=_params.get("_preload_content", True),
            _request_timeout=_params.get("_request_timeout"),
            collection_formats=_collection_formats,
            _request_auth=_params.get("_request_auth"),
        )

    @validate_call
    async def create_invitation(
        self,
        alias: Annotated[Optional[StrictStr], Field(description="Alias")] = None,
        auto_accept: Annotated[
            Optional[StrictBool],
            Field(description="Auto-accept connection (defaults to configuration)"),
        ] = None,
        multi_use: Annotated[
            Optional[StrictBool],
            Field(description="Create invitation for multiple use (default false)"),
        ] = None,
        public: Annotated[
            Optional[StrictBool],
            Field(description="Create invitation from public DID (default false)"),
        ] = None,
        body: Optional[CreateInvitationRequest] = None,
        **kwargs,
    ) -> InvitationResult:
        """Create a new connection invitation  # noqa: E501


        :param alias: Alias
        :type alias: str
        :param auto_accept: Auto-accept connection (defaults to configuration)
        :type auto_accept: bool
        :param multi_use: Create invitation for multiple use (default false)
        :type multi_use: bool
        :param public: Create invitation from public DID (default false)
        :type public: bool
        :param body:
        :type body: CreateInvitationRequest
        :param _request_timeout: timeout setting for this request.
               If one number provided, it will be total request
               timeout. It can also be a pair (tuple) of
               (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: InvitationResult
        """
        kwargs["_return_http_data_only"] = True
        if "_preload_content" in kwargs:
            message = "Error! Please call the create_invitation_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data"  # noqa: E501
            raise ValueError(message)

        return await self.create_invitation_with_http_info.raw_function(
            alias,
            auto_accept,
            multi_use,
            public,
            body,
            **kwargs,
        )

    @validate_call
    async def create_invitation_with_http_info(
        self,
        alias: Annotated[Optional[StrictStr], Field(description="Alias")] = None,
        auto_accept: Annotated[
            Optional[StrictBool],
            Field(description="Auto-accept connection (defaults to configuration)"),
        ] = None,
        multi_use: Annotated[
            Optional[StrictBool],
            Field(description="Create invitation for multiple use (default false)"),
        ] = None,
        public: Annotated[
            Optional[StrictBool],
            Field(description="Create invitation from public DID (default false)"),
        ] = None,
        body: Optional[CreateInvitationRequest] = None,
        **kwargs,
    ) -> ApiResponse:
        """Create a new connection invitation  # noqa: E501


        :param alias: Alias
        :type alias: str
        :param auto_accept: Auto-accept connection (defaults to configuration)
        :type auto_accept: bool
        :param multi_use: Create invitation for multiple use (default false)
        :type multi_use: bool
        :param public: Create invitation from public DID (default false)
        :type public: bool
        :param body:
        :type body: CreateInvitationRequest
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(InvitationResult, status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = ["alias", "auto_accept", "multi_use", "public", "body"]
        _all_params.extend(
            [
                "_return_http_data_only",
                "_preload_content",
                "_request_timeout",
                "_request_auth",
                "_content_type",
                "_headers",
            ]
        )

        # validate the arguments
        for _key, _val in _params["kwargs"].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method create_invitation" % _key
                )
            _params[_key] = _val
        del _params["kwargs"]

        _collection_formats: Dict[str, str] = {}

        # process the path parameters
        _path_params: Dict[str, str] = {}

        # process the query parameters
        _query_params: List[Tuple[str, str]] = []
        if _params.get("alias") is not None:  # noqa: E501
            _query_params.append(("alias", _params["alias"]))

        if _params.get("auto_accept") is not None:  # noqa: E501
            _query_params.append(("auto_accept", _params["auto_accept"]))

        if _params.get("multi_use") is not None:  # noqa: E501
            _query_params.append(("multi_use", _params["multi_use"]))

        if _params.get("public") is not None:  # noqa: E501
            _query_params.append(("public", _params["public"]))

        # process the header parameters
        _header_params = dict(_params.get("_headers", {}))
        # process the form parameters
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[str, str] = {}
        # process the body parameter
        _body_params = None
        if _params["body"] is not None:
            _body_params = _params["body"]

        # set the HTTP header `Accept`
        _header_params["Accept"] = self.api_client.select_header_accept(
            ["application/json"]
        )  # noqa: E501

        # set the HTTP header `Content-Type`
        _content_types_list = _params.get(
            "_content_type",
            self.api_client.select_header_content_type(["application/json"]),
        )
        if _content_types_list:
            _header_params["Content-Type"] = _content_types_list

        # authentication setting
        _auth_settings: List[str] = ["AuthorizationHeader"]  # noqa: E501

        _response_types_map: Dict[str, Optional[str]] = {
            "200": "InvitationResult",
        }

        return await self.api_client.call_api(
            "/connections/create-invitation",
            "POST",
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            _return_http_data_only=_params.get("_return_http_data_only"),  # noqa: E501
            _preload_content=_params.get("_preload_content", True),
            _request_timeout=_params.get("_request_timeout"),
            collection_formats=_collection_formats,
            _request_auth=_params.get("_request_auth"),
        )

    @validate_call
    async def create_static_connection(
        self,
        body: Optional[ConnectionStaticRequest] = None,
        **kwargs,
    ) -> ConnectionStaticResult:
        """Create a new static connection  # noqa: E501


        :param body:
        :type body: ConnectionStaticRequest
        :param _request_timeout: timeout setting for this request.
               If one number provided, it will be total request
               timeout. It can also be a pair (tuple) of
               (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: ConnectionStaticResult
        """
        kwargs["_return_http_data_only"] = True
        if "_preload_content" in kwargs:
            message = "Error! Please call the create_static_connection_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data"  # noqa: E501
            raise ValueError(message)

        return await self.create_static_connection_with_http_info.raw_function(
            body,
            **kwargs,
        )

    @validate_call
    async def create_static_connection_with_http_info(
        self,
        body: Optional[ConnectionStaticRequest] = None,
        **kwargs,
    ) -> ApiResponse:
        """Create a new static connection  # noqa: E501


        :param body:
        :type body: ConnectionStaticRequest
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(ConnectionStaticResult, status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = ["body"]
        _all_params.extend(
            [
                "_return_http_data_only",
                "_preload_content",
                "_request_timeout",
                "_request_auth",
                "_content_type",
                "_headers",
            ]
        )

        # validate the arguments
        for _key, _val in _params["kwargs"].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method create_static_connection" % _key
                )
            _params[_key] = _val
        del _params["kwargs"]

        _collection_formats: Dict[str, str] = {}

        # process the path parameters
        _path_params: Dict[str, str] = {}

        # process the query parameters
        _query_params: List[Tuple[str, str]] = []
        # process the header parameters
        _header_params = dict(_params.get("_headers", {}))
        # process the form parameters
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[str, str] = {}
        # process the body parameter
        _body_params = None
        if _params["body"] is not None:
            _body_params = _params["body"]

        # set the HTTP header `Accept`
        _header_params["Accept"] = self.api_client.select_header_accept(
            ["application/json"]
        )  # noqa: E501

        # set the HTTP header `Content-Type`
        _content_types_list = _params.get(
            "_content_type",
            self.api_client.select_header_content_type(["application/json"]),
        )
        if _content_types_list:
            _header_params["Content-Type"] = _content_types_list

        # authentication setting
        _auth_settings: List[str] = ["AuthorizationHeader"]  # noqa: E501

        _response_types_map: Dict[str, Optional[str]] = {
            "200": "ConnectionStaticResult",
        }

        return await self.api_client.call_api(
            "/connections/create-static",
            "POST",
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            _return_http_data_only=_params.get("_return_http_data_only"),  # noqa: E501
            _preload_content=_params.get("_preload_content", True),
            _request_timeout=_params.get("_request_timeout"),
            collection_formats=_collection_formats,
            _request_auth=_params.get("_request_auth"),
        )

    @validate_call
    async def delete_connection(
        self,
        conn_id: Annotated[StrictStr, Field(description="Connection identifier")],
        **kwargs,
    ) -> object:
        """Remove an existing connection record  # noqa: E501


        :param conn_id: Connection identifier (required)
        :type conn_id: str
        :param _request_timeout: timeout setting for this request.
               If one number provided, it will be total request
               timeout. It can also be a pair (tuple) of
               (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: object
        """
        kwargs["_return_http_data_only"] = True
        if "_preload_content" in kwargs:
            message = "Error! Please call the delete_connection_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data"  # noqa: E501
            raise ValueError(message)

        return await self.delete_connection_with_http_info.raw_function(
            conn_id,
            **kwargs,
        )

    @validate_call
    async def delete_connection_with_http_info(
        self,
        conn_id: Annotated[StrictStr, Field(description="Connection identifier")],
        **kwargs,
    ) -> ApiResponse:
        """Remove an existing connection record  # noqa: E501


        :param conn_id: Connection identifier (required)
        :type conn_id: str
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(object, status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = ["conn_id"]
        _all_params.extend(
            [
                "_return_http_data_only",
                "_preload_content",
                "_request_timeout",
                "_request_auth",
                "_content_type",
                "_headers",
            ]
        )

        # validate the arguments
        for _key, _val in _params["kwargs"].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method delete_connection" % _key
                )
            _params[_key] = _val
        del _params["kwargs"]

        _collection_formats: Dict[str, str] = {}

        # process the path parameters
        _path_params: Dict[str, str] = {}
        if _params["conn_id"] is not None:
            _path_params["conn_id"] = _params["conn_id"]

        # process the query parameters
        _query_params: List[Tuple[str, str]] = []
        # process the header parameters
        _header_params = dict(_params.get("_headers", {}))
        # process the form parameters
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[str, str] = {}
        # process the body parameter
        _body_params = None
        # set the HTTP header `Accept`
        _header_params["Accept"] = self.api_client.select_header_accept(
            ["application/json"]
        )  # noqa: E501

        # authentication setting
        _auth_settings: List[str] = ["AuthorizationHeader"]  # noqa: E501

        _response_types_map: Dict[str, Optional[str]] = {
            "200": "object",
        }

        return await self.api_client.call_api(
            "/connections/{conn_id}",
            "DELETE",
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            _return_http_data_only=_params.get("_return_http_data_only"),  # noqa: E501
            _preload_content=_params.get("_preload_content", True),
            _request_timeout=_params.get("_request_timeout"),
            collection_formats=_collection_formats,
            _request_auth=_params.get("_request_auth"),
        )

    @validate_call
    async def establish_inbound(
        self,
        conn_id: Annotated[StrictStr, Field(description="Connection identifier")],
        ref_id: Annotated[
            StrictStr, Field(description="Inbound connection identifier")
        ],
        **kwargs,
    ) -> object:
        """Assign another connection as the inbound connection  # noqa: E501


        :param conn_id: Connection identifier (required)
        :type conn_id: str
        :param ref_id: Inbound connection identifier (required)
        :type ref_id: str
        :param _request_timeout: timeout setting for this request.
               If one number provided, it will be total request
               timeout. It can also be a pair (tuple) of
               (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: object
        """
        kwargs["_return_http_data_only"] = True
        if "_preload_content" in kwargs:
            message = "Error! Please call the establish_inbound_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data"  # noqa: E501
            raise ValueError(message)

        return await self.establish_inbound_with_http_info.raw_function(
            conn_id,
            ref_id,
            **kwargs,
        )

    @validate_call
    async def establish_inbound_with_http_info(
        self,
        conn_id: Annotated[StrictStr, Field(description="Connection identifier")],
        ref_id: Annotated[
            StrictStr, Field(description="Inbound connection identifier")
        ],
        **kwargs,
    ) -> ApiResponse:
        """Assign another connection as the inbound connection  # noqa: E501


        :param conn_id: Connection identifier (required)
        :type conn_id: str
        :param ref_id: Inbound connection identifier (required)
        :type ref_id: str
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(object, status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = ["conn_id", "ref_id"]
        _all_params.extend(
            [
                "_return_http_data_only",
                "_preload_content",
                "_request_timeout",
                "_request_auth",
                "_content_type",
                "_headers",
            ]
        )

        # validate the arguments
        for _key, _val in _params["kwargs"].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method establish_inbound" % _key
                )
            _params[_key] = _val
        del _params["kwargs"]

        _collection_formats: Dict[str, str] = {}

        # process the path parameters
        _path_params: Dict[str, str] = {}
        if _params["conn_id"] is not None:
            _path_params["conn_id"] = _params["conn_id"]

        if _params["ref_id"] is not None:
            _path_params["ref_id"] = _params["ref_id"]

        # process the query parameters
        _query_params: List[Tuple[str, str]] = []
        # process the header parameters
        _header_params = dict(_params.get("_headers", {}))
        # process the form parameters
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[str, str] = {}
        # process the body parameter
        _body_params = None
        # set the HTTP header `Accept`
        _header_params["Accept"] = self.api_client.select_header_accept(
            ["application/json"]
        )  # noqa: E501

        # authentication setting
        _auth_settings: List[str] = ["AuthorizationHeader"]  # noqa: E501

        _response_types_map: Dict[str, Optional[str]] = {
            "200": "object",
        }

        return await self.api_client.call_api(
            "/connections/{conn_id}/establish-inbound/{ref_id}",
            "POST",
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            _return_http_data_only=_params.get("_return_http_data_only"),  # noqa: E501
            _preload_content=_params.get("_preload_content", True),
            _request_timeout=_params.get("_request_timeout"),
            collection_formats=_collection_formats,
            _request_auth=_params.get("_request_auth"),
        )

    @validate_call
    async def get_connection(
        self,
        conn_id: Annotated[StrictStr, Field(description="Connection identifier")],
        **kwargs,
    ) -> ConnRecord:
        """Fetch a single connection record  # noqa: E501


        :param conn_id: Connection identifier (required)
        :type conn_id: str
        :param _request_timeout: timeout setting for this request.
               If one number provided, it will be total request
               timeout. It can also be a pair (tuple) of
               (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: ConnRecord
        """
        kwargs["_return_http_data_only"] = True
        if "_preload_content" in kwargs:
            message = "Error! Please call the get_connection_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data"  # noqa: E501
            raise ValueError(message)

        return await self.get_connection_with_http_info.raw_function(
            conn_id,
            **kwargs,
        )

    @validate_call
    async def get_connection_with_http_info(
        self,
        conn_id: Annotated[StrictStr, Field(description="Connection identifier")],
        **kwargs,
    ) -> ApiResponse:
        """Fetch a single connection record  # noqa: E501


        :param conn_id: Connection identifier (required)
        :type conn_id: str
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(ConnRecord, status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = ["conn_id"]
        _all_params.extend(
            [
                "_return_http_data_only",
                "_preload_content",
                "_request_timeout",
                "_request_auth",
                "_content_type",
                "_headers",
            ]
        )

        # validate the arguments
        for _key, _val in _params["kwargs"].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_connection" % _key
                )
            _params[_key] = _val
        del _params["kwargs"]

        _collection_formats: Dict[str, str] = {}

        # process the path parameters
        _path_params: Dict[str, str] = {}
        if _params["conn_id"] is not None:
            _path_params["conn_id"] = _params["conn_id"]

        # process the query parameters
        _query_params: List[Tuple[str, str]] = []
        # process the header parameters
        _header_params = dict(_params.get("_headers", {}))
        # process the form parameters
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[str, str] = {}
        # process the body parameter
        _body_params = None
        # set the HTTP header `Accept`
        _header_params["Accept"] = self.api_client.select_header_accept(
            ["application/json"]
        )  # noqa: E501

        # authentication setting
        _auth_settings: List[str] = ["AuthorizationHeader"]  # noqa: E501

        _response_types_map: Dict[str, Optional[str]] = {
            "200": "ConnRecord",
        }

        return await self.api_client.call_api(
            "/connections/{conn_id}",
            "GET",
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            _return_http_data_only=_params.get("_return_http_data_only"),  # noqa: E501
            _preload_content=_params.get("_preload_content", True),
            _request_timeout=_params.get("_request_timeout"),
            collection_formats=_collection_formats,
            _request_auth=_params.get("_request_auth"),
        )

    @validate_call
    async def get_connection_endpoint(
        self,
        conn_id: Annotated[StrictStr, Field(description="Connection identifier")],
        **kwargs,
    ) -> EndpointsResult:
        """Fetch connection remote endpoint  # noqa: E501


        :param conn_id: Connection identifier (required)
        :type conn_id: str
        :param _request_timeout: timeout setting for this request.
               If one number provided, it will be total request
               timeout. It can also be a pair (tuple) of
               (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: EndpointsResult
        """
        kwargs["_return_http_data_only"] = True
        if "_preload_content" in kwargs:
            message = "Error! Please call the get_connection_endpoint_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data"  # noqa: E501
            raise ValueError(message)

        return await self.get_connection_endpoint_with_http_info.raw_function(
            conn_id,
            **kwargs,
        )

    @validate_call
    async def get_connection_endpoint_with_http_info(
        self,
        conn_id: Annotated[StrictStr, Field(description="Connection identifier")],
        **kwargs,
    ) -> ApiResponse:
        """Fetch connection remote endpoint  # noqa: E501


        :param conn_id: Connection identifier (required)
        :type conn_id: str
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(EndpointsResult, status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = ["conn_id"]
        _all_params.extend(
            [
                "_return_http_data_only",
                "_preload_content",
                "_request_timeout",
                "_request_auth",
                "_content_type",
                "_headers",
            ]
        )

        # validate the arguments
        for _key, _val in _params["kwargs"].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_connection_endpoint" % _key
                )
            _params[_key] = _val
        del _params["kwargs"]

        _collection_formats: Dict[str, str] = {}

        # process the path parameters
        _path_params: Dict[str, str] = {}
        if _params["conn_id"] is not None:
            _path_params["conn_id"] = _params["conn_id"]

        # process the query parameters
        _query_params: List[Tuple[str, str]] = []
        # process the header parameters
        _header_params = dict(_params.get("_headers", {}))
        # process the form parameters
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[str, str] = {}
        # process the body parameter
        _body_params = None
        # set the HTTP header `Accept`
        _header_params["Accept"] = self.api_client.select_header_accept(
            ["application/json"]
        )  # noqa: E501

        # authentication setting
        _auth_settings: List[str] = ["AuthorizationHeader"]  # noqa: E501

        _response_types_map: Dict[str, Optional[str]] = {
            "200": "EndpointsResult",
        }

        return await self.api_client.call_api(
            "/connections/{conn_id}/endpoints",
            "GET",
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            _return_http_data_only=_params.get("_return_http_data_only"),  # noqa: E501
            _preload_content=_params.get("_preload_content", True),
            _request_timeout=_params.get("_request_timeout"),
            collection_formats=_collection_formats,
            _request_auth=_params.get("_request_auth"),
        )

    @validate_call
    async def get_connections(
        self,
        alias: Annotated[Optional[StrictStr], Field(description="Alias")] = None,
        connection_protocol: Annotated[
            Optional[StrictStr], Field(description="Connection protocol used")
        ] = None,
        invitation_key: Annotated[
            Optional[StrictStr], Field(description="invitation key")
        ] = None,
        invitation_msg_id: Annotated[
            Optional[StrictStr],
            Field(description="Identifier of the associated Invitation Mesage"),
        ] = None,
        my_did: Annotated[Optional[StrictStr], Field(description="My DID")] = None,
        state: Annotated[
            Optional[StrictStr], Field(description="Connection state")
        ] = None,
        their_did: Annotated[
            Optional[StrictStr], Field(description="Their DID")
        ] = None,
        their_public_did: Annotated[
            Optional[StrictStr], Field(description="Their Public DID")
        ] = None,
        their_role: Annotated[
            Optional[StrictStr],
            Field(description="Their role in the connection protocol"),
        ] = None,
        **kwargs,
    ) -> ConnectionList:
        """Query agent-to-agent connections  # noqa: E501


        :param alias: Alias
        :type alias: str
        :param connection_protocol: Connection protocol used
        :type connection_protocol: str
        :param invitation_key: invitation key
        :type invitation_key: str
        :param invitation_msg_id: Identifier of the associated Invitation Mesage
        :type invitation_msg_id: str
        :param my_did: My DID
        :type my_did: str
        :param state: Connection state
        :type state: str
        :param their_did: Their DID
        :type their_did: str
        :param their_public_did: Their Public DID
        :type their_public_did: str
        :param their_role: Their role in the connection protocol
        :type their_role: str
        :param _request_timeout: timeout setting for this request.
               If one number provided, it will be total request
               timeout. It can also be a pair (tuple) of
               (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: ConnectionList
        """
        kwargs["_return_http_data_only"] = True
        if "_preload_content" in kwargs:
            message = "Error! Please call the get_connections_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data"  # noqa: E501
            raise ValueError(message)

        return await self.get_connections_with_http_info.raw_function(
            alias,
            connection_protocol,
            invitation_key,
            invitation_msg_id,
            my_did,
            state,
            their_did,
            their_public_did,
            their_role,
            **kwargs,
        )

    @validate_call
    async def get_connections_with_http_info(
        self,
        alias: Annotated[Optional[StrictStr], Field(description="Alias")] = None,
        connection_protocol: Annotated[
            Optional[StrictStr], Field(description="Connection protocol used")
        ] = None,
        invitation_key: Annotated[
            Optional[StrictStr], Field(description="invitation key")
        ] = None,
        invitation_msg_id: Annotated[
            Optional[StrictStr],
            Field(description="Identifier of the associated Invitation Mesage"),
        ] = None,
        my_did: Annotated[Optional[StrictStr], Field(description="My DID")] = None,
        state: Annotated[
            Optional[StrictStr], Field(description="Connection state")
        ] = None,
        their_did: Annotated[
            Optional[StrictStr], Field(description="Their DID")
        ] = None,
        their_public_did: Annotated[
            Optional[StrictStr], Field(description="Their Public DID")
        ] = None,
        their_role: Annotated[
            Optional[StrictStr],
            Field(description="Their role in the connection protocol"),
        ] = None,
        **kwargs,
    ) -> ApiResponse:
        """Query agent-to-agent connections  # noqa: E501


        :param alias: Alias
        :type alias: str
        :param connection_protocol: Connection protocol used
        :type connection_protocol: str
        :param invitation_key: invitation key
        :type invitation_key: str
        :param invitation_msg_id: Identifier of the associated Invitation Mesage
        :type invitation_msg_id: str
        :param my_did: My DID
        :type my_did: str
        :param state: Connection state
        :type state: str
        :param their_did: Their DID
        :type their_did: str
        :param their_public_did: Their Public DID
        :type their_public_did: str
        :param their_role: Their role in the connection protocol
        :type their_role: str
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(ConnectionList, status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = [
            "alias",
            "connection_protocol",
            "invitation_key",
            "invitation_msg_id",
            "my_did",
            "state",
            "their_did",
            "their_public_did",
            "their_role",
        ]
        _all_params.extend(
            [
                "_return_http_data_only",
                "_preload_content",
                "_request_timeout",
                "_request_auth",
                "_content_type",
                "_headers",
            ]
        )

        # validate the arguments
        for _key, _val in _params["kwargs"].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_connections" % _key
                )
            _params[_key] = _val
        del _params["kwargs"]

        _collection_formats: Dict[str, str] = {}

        # process the path parameters
        _path_params: Dict[str, str] = {}

        # process the query parameters
        _query_params: List[Tuple[str, str]] = []
        if _params.get("alias") is not None:  # noqa: E501
            _query_params.append(("alias", _params["alias"]))

        if _params.get("connection_protocol") is not None:  # noqa: E501
            _query_params.append(
                ("connection_protocol", _params["connection_protocol"])
            )

        if _params.get("invitation_key") is not None:  # noqa: E501
            _query_params.append(("invitation_key", _params["invitation_key"]))

        if _params.get("invitation_msg_id") is not None:  # noqa: E501
            _query_params.append(("invitation_msg_id", _params["invitation_msg_id"]))

        if _params.get("my_did") is not None:  # noqa: E501
            _query_params.append(("my_did", _params["my_did"]))

        if _params.get("state") is not None:  # noqa: E501
            _query_params.append(("state", _params["state"]))

        if _params.get("their_did") is not None:  # noqa: E501
            _query_params.append(("their_did", _params["their_did"]))

        if _params.get("their_public_did") is not None:  # noqa: E501
            _query_params.append(("their_public_did", _params["their_public_did"]))

        if _params.get("their_role") is not None:  # noqa: E501
            _query_params.append(("their_role", _params["their_role"]))

        # process the header parameters
        _header_params = dict(_params.get("_headers", {}))
        # process the form parameters
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[str, str] = {}
        # process the body parameter
        _body_params = None
        # set the HTTP header `Accept`
        _header_params["Accept"] = self.api_client.select_header_accept(
            ["application/json"]
        )  # noqa: E501

        # authentication setting
        _auth_settings: List[str] = ["AuthorizationHeader"]  # noqa: E501

        _response_types_map: Dict[str, Optional[str]] = {
            "200": "ConnectionList",
        }

        return await self.api_client.call_api(
            "/connections",
            "GET",
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            _return_http_data_only=_params.get("_return_http_data_only"),  # noqa: E501
            _preload_content=_params.get("_preload_content", True),
            _request_timeout=_params.get("_request_timeout"),
            collection_formats=_collection_formats,
            _request_auth=_params.get("_request_auth"),
        )

    @validate_call
    async def get_metadata(
        self,
        conn_id: Annotated[StrictStr, Field(description="Connection identifier")],
        key: Annotated[
            Optional[StrictStr], Field(description="Key to retrieve.")
        ] = None,
        **kwargs,
    ) -> ConnectionMetadata:
        """Fetch connection metadata  # noqa: E501


        :param conn_id: Connection identifier (required)
        :type conn_id: str
        :param key: Key to retrieve.
        :type key: str
        :param _request_timeout: timeout setting for this request.
               If one number provided, it will be total request
               timeout. It can also be a pair (tuple) of
               (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: ConnectionMetadata
        """
        kwargs["_return_http_data_only"] = True
        if "_preload_content" in kwargs:
            message = "Error! Please call the get_metadata_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data"  # noqa: E501
            raise ValueError(message)

        return await self.get_metadata_with_http_info.raw_function(
            conn_id,
            key,
            **kwargs,
        )

    @validate_call
    async def get_metadata_with_http_info(
        self,
        conn_id: Annotated[StrictStr, Field(description="Connection identifier")],
        key: Annotated[
            Optional[StrictStr], Field(description="Key to retrieve.")
        ] = None,
        **kwargs,
    ) -> ApiResponse:
        """Fetch connection metadata  # noqa: E501


        :param conn_id: Connection identifier (required)
        :type conn_id: str
        :param key: Key to retrieve.
        :type key: str
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(ConnectionMetadata, status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = ["conn_id", "key"]
        _all_params.extend(
            [
                "_return_http_data_only",
                "_preload_content",
                "_request_timeout",
                "_request_auth",
                "_content_type",
                "_headers",
            ]
        )

        # validate the arguments
        for _key, _val in _params["kwargs"].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method get_metadata" % _key
                )
            _params[_key] = _val
        del _params["kwargs"]

        _collection_formats: Dict[str, str] = {}

        # process the path parameters
        _path_params: Dict[str, str] = {}
        if _params["conn_id"] is not None:
            _path_params["conn_id"] = _params["conn_id"]

        # process the query parameters
        _query_params: List[Tuple[str, str]] = []
        if _params.get("key") is not None:  # noqa: E501
            _query_params.append(("key", _params["key"]))

        # process the header parameters
        _header_params = dict(_params.get("_headers", {}))
        # process the form parameters
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[str, str] = {}
        # process the body parameter
        _body_params = None
        # set the HTTP header `Accept`
        _header_params["Accept"] = self.api_client.select_header_accept(
            ["application/json"]
        )  # noqa: E501

        # authentication setting
        _auth_settings: List[str] = ["AuthorizationHeader"]  # noqa: E501

        _response_types_map: Dict[str, Optional[str]] = {
            "200": "ConnectionMetadata",
        }

        return await self.api_client.call_api(
            "/connections/{conn_id}/metadata",
            "GET",
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            _return_http_data_only=_params.get("_return_http_data_only"),  # noqa: E501
            _preload_content=_params.get("_preload_content", True),
            _request_timeout=_params.get("_request_timeout"),
            collection_formats=_collection_formats,
            _request_auth=_params.get("_request_auth"),
        )

    @validate_call
    async def receive_invitation(
        self,
        alias: Annotated[Optional[StrictStr], Field(description="Alias")] = None,
        auto_accept: Annotated[
            Optional[StrictBool],
            Field(description="Auto-accept connection (defaults to configuration)"),
        ] = None,
        mediation_id: Annotated[
            Optional[StrictStr],
            Field(description="Identifier for active mediation record to be used"),
        ] = None,
        body: Optional[ReceiveInvitationRequest] = None,
        **kwargs,
    ) -> ConnRecord:
        """Receive a new connection invitation  # noqa: E501


        :param alias: Alias
        :type alias: str
        :param auto_accept: Auto-accept connection (defaults to configuration)
        :type auto_accept: bool
        :param mediation_id: Identifier for active mediation record to be used
        :type mediation_id: str
        :param body:
        :type body: ReceiveInvitationRequest
        :param _request_timeout: timeout setting for this request.
               If one number provided, it will be total request
               timeout. It can also be a pair (tuple) of
               (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: ConnRecord
        """
        kwargs["_return_http_data_only"] = True
        if "_preload_content" in kwargs:
            message = "Error! Please call the receive_invitation_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data"  # noqa: E501
            raise ValueError(message)

        return await self.receive_invitation_with_http_info.raw_function(
            alias,
            auto_accept,
            mediation_id,
            body,
            **kwargs,
        )

    @validate_call
    async def receive_invitation_with_http_info(
        self,
        alias: Annotated[Optional[StrictStr], Field(description="Alias")] = None,
        auto_accept: Annotated[
            Optional[StrictBool],
            Field(description="Auto-accept connection (defaults to configuration)"),
        ] = None,
        mediation_id: Annotated[
            Optional[StrictStr],
            Field(description="Identifier for active mediation record to be used"),
        ] = None,
        body: Optional[ReceiveInvitationRequest] = None,
        **kwargs,
    ) -> ApiResponse:
        """Receive a new connection invitation  # noqa: E501


        :param alias: Alias
        :type alias: str
        :param auto_accept: Auto-accept connection (defaults to configuration)
        :type auto_accept: bool
        :param mediation_id: Identifier for active mediation record to be used
        :type mediation_id: str
        :param body:
        :type body: ReceiveInvitationRequest
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(ConnRecord, status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = ["alias", "auto_accept", "mediation_id", "body"]
        _all_params.extend(
            [
                "_return_http_data_only",
                "_preload_content",
                "_request_timeout",
                "_request_auth",
                "_content_type",
                "_headers",
            ]
        )

        # validate the arguments
        for _key, _val in _params["kwargs"].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method receive_invitation" % _key
                )
            _params[_key] = _val
        del _params["kwargs"]

        _collection_formats: Dict[str, str] = {}

        # process the path parameters
        _path_params: Dict[str, str] = {}

        # process the query parameters
        _query_params: List[Tuple[str, str]] = []
        if _params.get("alias") is not None:  # noqa: E501
            _query_params.append(("alias", _params["alias"]))

        if _params.get("auto_accept") is not None:  # noqa: E501
            _query_params.append(("auto_accept", _params["auto_accept"]))

        if _params.get("mediation_id") is not None:  # noqa: E501
            _query_params.append(("mediation_id", _params["mediation_id"]))

        # process the header parameters
        _header_params = dict(_params.get("_headers", {}))
        # process the form parameters
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[str, str] = {}
        # process the body parameter
        _body_params = None
        if _params["body"] is not None:
            _body_params = _params["body"]

        # set the HTTP header `Accept`
        _header_params["Accept"] = self.api_client.select_header_accept(
            ["application/json"]
        )  # noqa: E501

        # set the HTTP header `Content-Type`
        _content_types_list = _params.get(
            "_content_type",
            self.api_client.select_header_content_type(["application/json"]),
        )
        if _content_types_list:
            _header_params["Content-Type"] = _content_types_list

        # authentication setting
        _auth_settings: List[str] = ["AuthorizationHeader"]  # noqa: E501

        _response_types_map: Dict[str, Optional[str]] = {
            "200": "ConnRecord",
        }

        return await self.api_client.call_api(
            "/connections/receive-invitation",
            "POST",
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            _return_http_data_only=_params.get("_return_http_data_only"),  # noqa: E501
            _preload_content=_params.get("_preload_content", True),
            _request_timeout=_params.get("_request_timeout"),
            collection_formats=_collection_formats,
            _request_auth=_params.get("_request_auth"),
        )

    @validate_call
    async def set_metadata(
        self,
        conn_id: Annotated[StrictStr, Field(description="Connection identifier")],
        body: Optional[ConnectionMetadataSetRequest] = None,
        **kwargs,
    ) -> ConnectionMetadata:
        """Set connection metadata  # noqa: E501


        :param conn_id: Connection identifier (required)
        :type conn_id: str
        :param body:
        :type body: ConnectionMetadataSetRequest
        :param _request_timeout: timeout setting for this request.
               If one number provided, it will be total request
               timeout. It can also be a pair (tuple) of
               (connection, read) timeouts.
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: ConnectionMetadata
        """
        kwargs["_return_http_data_only"] = True
        if "_preload_content" in kwargs:
            message = "Error! Please call the set_metadata_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data"  # noqa: E501
            raise ValueError(message)

        return await self.set_metadata_with_http_info.raw_function(
            conn_id,
            body,
            **kwargs,
        )

    @validate_call
    async def set_metadata_with_http_info(
        self,
        conn_id: Annotated[StrictStr, Field(description="Connection identifier")],
        body: Optional[ConnectionMetadataSetRequest] = None,
        **kwargs,
    ) -> ApiResponse:
        """Set connection metadata  # noqa: E501


        :param conn_id: Connection identifier (required)
        :type conn_id: str
        :param body:
        :type body: ConnectionMetadataSetRequest
        :param _preload_content: if False, the ApiResponse.data will
                                 be set to none and raw_data will store the
                                 HTTP response body without reading/decoding.
                                 Default is True.
        :type _preload_content: bool, optional
        :param _return_http_data_only: response data instead of ApiResponse
                                       object with status code, headers, etc
        :type _return_http_data_only: bool, optional
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :type _request_auth: dict, optional
        :type _content_type: string, optional: force content-type for the request
        :return: Returns the result object.
                 If the method is called asynchronously,
                 returns the request thread.
        :rtype: tuple(ConnectionMetadata, status_code(int), headers(HTTPHeaderDict))
        """

        _params = locals()

        _all_params = ["conn_id", "body"]
        _all_params.extend(
            [
                "_return_http_data_only",
                "_preload_content",
                "_request_timeout",
                "_request_auth",
                "_content_type",
                "_headers",
            ]
        )

        # validate the arguments
        for _key, _val in _params["kwargs"].items():
            if _key not in _all_params:
                raise ApiTypeError(
                    "Got an unexpected keyword argument '%s'"
                    " to method set_metadata" % _key
                )
            _params[_key] = _val
        del _params["kwargs"]

        _collection_formats: Dict[str, str] = {}

        # process the path parameters
        _path_params: Dict[str, str] = {}
        if _params["conn_id"] is not None:
            _path_params["conn_id"] = _params["conn_id"]

        # process the query parameters
        _query_params: List[Tuple[str, str]] = []
        # process the header parameters
        _header_params = dict(_params.get("_headers", {}))
        # process the form parameters
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[str, str] = {}
        # process the body parameter
        _body_params = None
        if _params["body"] is not None:
            _body_params = _params["body"]

        # set the HTTP header `Accept`
        _header_params["Accept"] = self.api_client.select_header_accept(
            ["application/json"]
        )  # noqa: E501

        # set the HTTP header `Content-Type`
        _content_types_list = _params.get(
            "_content_type",
            self.api_client.select_header_content_type(["application/json"]),
        )
        if _content_types_list:
            _header_params["Content-Type"] = _content_types_list

        # authentication setting
        _auth_settings: List[str] = ["AuthorizationHeader"]  # noqa: E501

        _response_types_map: Dict[str, Optional[str]] = {
            "200": "ConnectionMetadata",
        }

        return await self.api_client.call_api(
            "/connections/{conn_id}/metadata",
            "POST",
            _path_params,
            _query_params,
            _header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            response_types_map=_response_types_map,
            auth_settings=_auth_settings,
            _return_http_data_only=_params.get("_return_http_data_only"),  # noqa: E501
            _preload_content=_params.get("_preload_content", True),
            _request_timeout=_params.get("_request_timeout"),
            collection_formats=_collection_formats,
            _request_auth=_params.get("_request_auth"),
        )