default_api.py

# coding: utf-8

"""
    STACKIT IaaS API

    This API allows you to create and modify IaaS resources.

    The version of the OpenAPI document: 2alpha1
    Contact: stackit-iaas@mail.schwarz
    Generated by OpenAPI Generator (https://openapi-generator.tech)

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

from typing import Any, Dict, List, Optional, Tuple, Union
from uuid import UUID

from pydantic import Field, StrictFloat, StrictInt, StrictStr, validate_call
from stackit.core.configuration import Configuration
from typing_extensions import Annotated

from stackit.iaasalpha.api_client import ApiClient, RequestSerialized
from stackit.iaasalpha.api_response import ApiResponse
from stackit.iaasalpha.models.add_routes_to_routing_table_payload import (
    AddRoutesToRoutingTablePayload,
)
from stackit.iaasalpha.models.add_routing_table_to_area_payload import (
    AddRoutingTableToAreaPayload,
)
from stackit.iaasalpha.models.create_network_payload import CreateNetworkPayload
from stackit.iaasalpha.models.network import Network
from stackit.iaasalpha.models.network_list_response import NetworkListResponse
from stackit.iaasalpha.models.partial_update_network_payload import (
    PartialUpdateNetworkPayload,
)
from stackit.iaasalpha.models.route import Route
from stackit.iaasalpha.models.route_list_response import RouteListResponse
from stackit.iaasalpha.models.routing_table import RoutingTable
from stackit.iaasalpha.models.routing_table_list_response import (
    RoutingTableListResponse,
)
from stackit.iaasalpha.models.update_route_of_routing_table_payload import (
    UpdateRouteOfRoutingTablePayload,
)
from stackit.iaasalpha.models.update_routing_table_of_area_payload import (
    UpdateRoutingTableOfAreaPayload,
)
from stackit.iaasalpha.rest import RESTResponseType


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

    Do not edit the class manually.
    """

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

    @validate_call
    def add_routes_to_routing_table(
        self,
        organization_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Organization.")],
        area_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Network Area.")],
        region: Annotated[StrictStr, Field(description="The STACKIT Region of the resources.")],
        routing_table_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Routing Table.")],
        add_routes_to_routing_table_payload: Annotated[
            AddRoutesToRoutingTablePayload, Field(description="Request an addition of routes to a routing table.")
        ],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RouteListResponse:
        """Create new routes in a routing table.

        Create new routes in an existing routing table.

        :param organization_id: The identifier (ID) of a STACKIT Organization. (required)
        :type organization_id: UUID
        :param area_id: The identifier (ID) of a STACKIT Network Area. (required)
        :type area_id: UUID
        :param region: The STACKIT Region of the resources. (required)
        :type region: str
        :param routing_table_id: The identifier (ID) of a STACKIT Routing Table. (required)
        :type routing_table_id: UUID
        :param add_routes_to_routing_table_payload: Request an addition of routes to a routing table. (required)
        :type add_routes_to_routing_table_payload: AddRoutesToRoutingTablePayload
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :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
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """  # noqa: E501

        _param = self._add_routes_to_routing_table_serialize(
            organization_id=organization_id,
            area_id=area_id,
            region=region,
            routing_table_id=routing_table_id,
            add_routes_to_routing_table_payload=add_routes_to_routing_table_payload,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "201": "RouteListResponse",
            "400": "Error",
            "401": "Error",
            "403": "Error",
            "404": "Error",
            "409": "Error",
            "500": "Error",
        }
        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data

    @validate_call
    def add_routes_to_routing_table_with_http_info(
        self,
        organization_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Organization.")],
        area_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Network Area.")],
        region: Annotated[StrictStr, Field(description="The STACKIT Region of the resources.")],
        routing_table_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Routing Table.")],
        add_routes_to_routing_table_payload: Annotated[
            AddRoutesToRoutingTablePayload, Field(description="Request an addition of routes to a routing table.")
        ],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[RouteListResponse]:
        """Create new routes in a routing table.

        Create new routes in an existing routing table.

        :param organization_id: The identifier (ID) of a STACKIT Organization. (required)
        :type organization_id: UUID
        :param area_id: The identifier (ID) of a STACKIT Network Area. (required)
        :type area_id: UUID
        :param region: The STACKIT Region of the resources. (required)
        :type region: str
        :param routing_table_id: The identifier (ID) of a STACKIT Routing Table. (required)
        :type routing_table_id: UUID
        :param add_routes_to_routing_table_payload: Request an addition of routes to a routing table. (required)
        :type add_routes_to_routing_table_payload: AddRoutesToRoutingTablePayload
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :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
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """  # noqa: E501

        _param = self._add_routes_to_routing_table_serialize(
            organization_id=organization_id,
            area_id=area_id,
            region=region,
            routing_table_id=routing_table_id,
            add_routes_to_routing_table_payload=add_routes_to_routing_table_payload,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "201": "RouteListResponse",
            "400": "Error",
            "401": "Error",
            "403": "Error",
            "404": "Error",
            "409": "Error",
            "500": "Error",
        }
        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )

    @validate_call
    def add_routes_to_routing_table_without_preload_content(
        self,
        organization_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Organization.")],
        area_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Network Area.")],
        region: Annotated[StrictStr, Field(description="The STACKIT Region of the resources.")],
        routing_table_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Routing Table.")],
        add_routes_to_routing_table_payload: Annotated[
            AddRoutesToRoutingTablePayload, Field(description="Request an addition of routes to a routing table.")
        ],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Create new routes in a routing table.

        Create new routes in an existing routing table.

        :param organization_id: The identifier (ID) of a STACKIT Organization. (required)
        :type organization_id: UUID
        :param area_id: The identifier (ID) of a STACKIT Network Area. (required)
        :type area_id: UUID
        :param region: The STACKIT Region of the resources. (required)
        :type region: str
        :param routing_table_id: The identifier (ID) of a STACKIT Routing Table. (required)
        :type routing_table_id: UUID
        :param add_routes_to_routing_table_payload: Request an addition of routes to a routing table. (required)
        :type add_routes_to_routing_table_payload: AddRoutesToRoutingTablePayload
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :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
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """  # noqa: E501

        _param = self._add_routes_to_routing_table_serialize(
            organization_id=organization_id,
            area_id=area_id,
            region=region,
            routing_table_id=routing_table_id,
            add_routes_to_routing_table_payload=add_routes_to_routing_table_payload,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "201": "RouteListResponse",
            "400": "Error",
            "401": "Error",
            "403": "Error",
            "404": "Error",
            "409": "Error",
            "500": "Error",
        }
        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
        return response_data.response

    def _add_routes_to_routing_table_serialize(
        self,
        organization_id,
        area_id,
        region,
        routing_table_id,
        add_routes_to_routing_table_payload,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {}

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if organization_id is not None:
            _path_params["organizationId"] = organization_id
        if area_id is not None:
            _path_params["areaId"] = area_id
        if region is not None:
            _path_params["region"] = region
        if routing_table_id is not None:
            _path_params["routingTableId"] = routing_table_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if add_routes_to_routing_table_payload is not None:
            _body_params = add_routes_to_routing_table_payload

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

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params["Content-Type"] = _content_type
        else:
            _default_content_type = self.api_client.select_header_content_type(["application/json"])
            if _default_content_type is not None:
                _header_params["Content-Type"] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = []

        return self.api_client.param_serialize(
            method="POST",
            resource_path="/v2alpha1/organizations/{organizationId}/network-areas/{areaId}/regions/{region}/routing-tables/{routingTableId}/routes",
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth,
        )

    @validate_call
    def add_routing_table_to_area(
        self,
        organization_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Organization.")],
        area_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Network Area.")],
        region: Annotated[StrictStr, Field(description="The STACKIT Region of the resources.")],
        add_routing_table_to_area_payload: Annotated[
            AddRoutingTableToAreaPayload, Field(description="Request an addition of a routing table to an area.")
        ],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RoutingTable:
        """Create new routing table in a network area.

        Create a new routing table in an existing network area.

        :param organization_id: The identifier (ID) of a STACKIT Organization. (required)
        :type organization_id: UUID
        :param area_id: The identifier (ID) of a STACKIT Network Area. (required)
        :type area_id: UUID
        :param region: The STACKIT Region of the resources. (required)
        :type region: str
        :param add_routing_table_to_area_payload: Request an addition of a routing table to an area. (required)
        :type add_routing_table_to_area_payload: AddRoutingTableToAreaPayload
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :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
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """  # noqa: E501

        _param = self._add_routing_table_to_area_serialize(
            organization_id=organization_id,
            area_id=area_id,
            region=region,
            add_routing_table_to_area_payload=add_routing_table_to_area_payload,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "201": "RoutingTable",
            "400": "Error",
            "401": "Error",
            "403": "Error",
            "404": "Error",
            "409": "Error",
            "500": "Error",
        }
        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data

    @validate_call
    def add_routing_table_to_area_with_http_info(
        self,
        organization_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Organization.")],
        area_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Network Area.")],
        region: Annotated[StrictStr, Field(description="The STACKIT Region of the resources.")],
        add_routing_table_to_area_payload: Annotated[
            AddRoutingTableToAreaPayload, Field(description="Request an addition of a routing table to an area.")
        ],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[RoutingTable]:
        """Create new routing table in a network area.

        Create a new routing table in an existing network area.

        :param organization_id: The identifier (ID) of a STACKIT Organization. (required)
        :type organization_id: UUID
        :param area_id: The identifier (ID) of a STACKIT Network Area. (required)
        :type area_id: UUID
        :param region: The STACKIT Region of the resources. (required)
        :type region: str
        :param add_routing_table_to_area_payload: Request an addition of a routing table to an area. (required)
        :type add_routing_table_to_area_payload: AddRoutingTableToAreaPayload
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :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
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """  # noqa: E501

        _param = self._add_routing_table_to_area_serialize(
            organization_id=organization_id,
            area_id=area_id,
            region=region,
            add_routing_table_to_area_payload=add_routing_table_to_area_payload,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "201": "RoutingTable",
            "400": "Error",
            "401": "Error",
            "403": "Error",
            "404": "Error",
            "409": "Error",
            "500": "Error",
        }
        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )

    @validate_call
    def add_routing_table_to_area_without_preload_content(
        self,
        organization_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Organization.")],
        area_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Network Area.")],
        region: Annotated[StrictStr, Field(description="The STACKIT Region of the resources.")],
        add_routing_table_to_area_payload: Annotated[
            AddRoutingTableToAreaPayload, Field(description="Request an addition of a routing table to an area.")
        ],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Create new routing table in a network area.

        Create a new routing table in an existing network area.

        :param organization_id: The identifier (ID) of a STACKIT Organization. (required)
        :type organization_id: UUID
        :param area_id: The identifier (ID) of a STACKIT Network Area. (required)
        :type area_id: UUID
        :param region: The STACKIT Region of the resources. (required)
        :type region: str
        :param add_routing_table_to_area_payload: Request an addition of a routing table to an area. (required)
        :type add_routing_table_to_area_payload: AddRoutingTableToAreaPayload
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :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
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """  # noqa: E501

        _param = self._add_routing_table_to_area_serialize(
            organization_id=organization_id,
            area_id=area_id,
            region=region,
            add_routing_table_to_area_payload=add_routing_table_to_area_payload,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "201": "RoutingTable",
            "400": "Error",
            "401": "Error",
            "403": "Error",
            "404": "Error",
            "409": "Error",
            "500": "Error",
        }
        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
        return response_data.response

    def _add_routing_table_to_area_serialize(
        self,
        organization_id,
        area_id,
        region,
        add_routing_table_to_area_payload,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {}

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if organization_id is not None:
            _path_params["organizationId"] = organization_id
        if area_id is not None:
            _path_params["areaId"] = area_id
        if region is not None:
            _path_params["region"] = region
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if add_routing_table_to_area_payload is not None:
            _body_params = add_routing_table_to_area_payload

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

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params["Content-Type"] = _content_type
        else:
            _default_content_type = self.api_client.select_header_content_type(["application/json"])
            if _default_content_type is not None:
                _header_params["Content-Type"] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = []

        return self.api_client.param_serialize(
            method="POST",
            resource_path="/v2alpha1/organizations/{organizationId}/network-areas/{areaId}/regions/{region}/routing-tables",
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth,
        )

    @validate_call
    def create_network(
        self,
        project_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Project.")],
        region: Annotated[StrictStr, Field(description="The STACKIT Region of the resources.")],
        create_network_payload: Annotated[CreateNetworkPayload, Field(description="Request a network creation.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> Network:
        """Create new network.

        Create a new network in a project. `nameservers` will be filled from `defaultNameservers` of the respective area if not specified. If the project has `internetAccess` enabled and this is the first network in the project this might incur cost.

        :param project_id: The identifier (ID) of a STACKIT Project. (required)
        :type project_id: UUID
        :param region: The STACKIT Region of the resources. (required)
        :type region: str
        :param create_network_payload: Request a network creation. (required)
        :type create_network_payload: CreateNetworkPayload
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :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
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """  # noqa: E501

        _param = self._create_network_serialize(
            project_id=project_id,
            region=region,
            create_network_payload=create_network_payload,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "202": "Network",
            "400": "Error",
            "401": "Error",
            "403": "Error",
            "404": "Error",
            "409": "Error",
            "500": "Error",
        }
        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data

    @validate_call
    def create_network_with_http_info(
        self,
        project_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Project.")],
        region: Annotated[StrictStr, Field(description="The STACKIT Region of the resources.")],
        create_network_payload: Annotated[CreateNetworkPayload, Field(description="Request a network creation.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[Network]:
        """Create new network.

        Create a new network in a project. `nameservers` will be filled from `defaultNameservers` of the respective area if not specified. If the project has `internetAccess` enabled and this is the first network in the project this might incur cost.

        :param project_id: The identifier (ID) of a STACKIT Project. (required)
        :type project_id: UUID
        :param region: The STACKIT Region of the resources. (required)
        :type region: str
        :param create_network_payload: Request a network creation. (required)
        :type create_network_payload: CreateNetworkPayload
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :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
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """  # noqa: E501

        _param = self._create_network_serialize(
            project_id=project_id,
            region=region,
            create_network_payload=create_network_payload,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "202": "Network",
            "400": "Error",
            "401": "Error",
            "403": "Error",
            "404": "Error",
            "409": "Error",
            "500": "Error",
        }
        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )

    @validate_call
    def create_network_without_preload_content(
        self,
        project_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Project.")],
        region: Annotated[StrictStr, Field(description="The STACKIT Region of the resources.")],
        create_network_payload: Annotated[CreateNetworkPayload, Field(description="Request a network creation.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Create new network.

        Create a new network in a project. `nameservers` will be filled from `defaultNameservers` of the respective area if not specified. If the project has `internetAccess` enabled and this is the first network in the project this might incur cost.

        :param project_id: The identifier (ID) of a STACKIT Project. (required)
        :type project_id: UUID
        :param region: The STACKIT Region of the resources. (required)
        :type region: str
        :param create_network_payload: Request a network creation. (required)
        :type create_network_payload: CreateNetworkPayload
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :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
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """  # noqa: E501

        _param = self._create_network_serialize(
            project_id=project_id,
            region=region,
            create_network_payload=create_network_payload,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "202": "Network",
            "400": "Error",
            "401": "Error",
            "403": "Error",
            "404": "Error",
            "409": "Error",
            "500": "Error",
        }
        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
        return response_data.response

    def _create_network_serialize(
        self,
        project_id,
        region,
        create_network_payload,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {}

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params["projectId"] = project_id
        if region is not None:
            _path_params["region"] = region
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if create_network_payload is not None:
            _body_params = create_network_payload

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

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params["Content-Type"] = _content_type
        else:
            _default_content_type = self.api_client.select_header_content_type(["application/json"])
            if _default_content_type is not None:
                _header_params["Content-Type"] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = []

        return self.api_client.param_serialize(
            method="POST",
            resource_path="/v2alpha1/projects/{projectId}/regions/{region}/networks",
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth,
        )

    @validate_call
    def delete_network(
        self,
        project_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Project.")],
        region: Annotated[StrictStr, Field(description="The STACKIT Region of the resources.")],
        network_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Network.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """Delete network.

        Delete a network. If the network is still in use, the deletion will fail.

        :param project_id: The identifier (ID) of a STACKIT Project. (required)
        :type project_id: UUID
        :param region: The STACKIT Region of the resources. (required)
        :type region: str
        :param network_id: The identifier (ID) of a STACKIT Network. (required)
        :type network_id: UUID
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :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
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """  # noqa: E501

        _param = self._delete_network_serialize(
            project_id=project_id,
            region=region,
            network_id=network_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "202": None,
            "400": "Error",
            "401": "Error",
            "403": "Error",
            "404": "Error",
            "409": "Error",
            "500": "Error",
        }
        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data

    @validate_call
    def delete_network_with_http_info(
        self,
        project_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Project.")],
        region: Annotated[StrictStr, Field(description="The STACKIT Region of the resources.")],
        network_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Network.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """Delete network.

        Delete a network. If the network is still in use, the deletion will fail.

        :param project_id: The identifier (ID) of a STACKIT Project. (required)
        :type project_id: UUID
        :param region: The STACKIT Region of the resources. (required)
        :type region: str
        :param network_id: The identifier (ID) of a STACKIT Network. (required)
        :type network_id: UUID
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :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
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """  # noqa: E501

        _param = self._delete_network_serialize(
            project_id=project_id,
            region=region,
            network_id=network_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "202": None,
            "400": "Error",
            "401": "Error",
            "403": "Error",
            "404": "Error",
            "409": "Error",
            "500": "Error",
        }
        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )

    @validate_call
    def delete_network_without_preload_content(
        self,
        project_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Project.")],
        region: Annotated[StrictStr, Field(description="The STACKIT Region of the resources.")],
        network_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Network.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Delete network.

        Delete a network. If the network is still in use, the deletion will fail.

        :param project_id: The identifier (ID) of a STACKIT Project. (required)
        :type project_id: UUID
        :param region: The STACKIT Region of the resources. (required)
        :type region: str
        :param network_id: The identifier (ID) of a STACKIT Network. (required)
        :type network_id: UUID
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :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
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """  # noqa: E501

        _param = self._delete_network_serialize(
            project_id=project_id,
            region=region,
            network_id=network_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "202": None,
            "400": "Error",
            "401": "Error",
            "403": "Error",
            "404": "Error",
            "409": "Error",
            "500": "Error",
        }
        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
        return response_data.response

    def _delete_network_serialize(
        self,
        project_id,
        region,
        network_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {}

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params["projectId"] = project_id
        if region is not None:
            _path_params["region"] = region
        if network_id is not None:
            _path_params["networkId"] = network_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter

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

        # authentication setting
        _auth_settings: List[str] = []

        return self.api_client.param_serialize(
            method="DELETE",
            resource_path="/v2alpha1/projects/{projectId}/regions/{region}/networks/{networkId}",
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth,
        )

    @validate_call
    def delete_route_from_routing_table(
        self,
        organization_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Organization.")],
        area_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Network Area.")],
        region: Annotated[StrictStr, Field(description="The STACKIT Region of the resources.")],
        routing_table_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Routing Table.")],
        route_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Route.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """Delete a route in a routing table.

        Delete a route in an existing routing table.

        :param organization_id: The identifier (ID) of a STACKIT Organization. (required)
        :type organization_id: UUID
        :param area_id: The identifier (ID) of a STACKIT Network Area. (required)
        :type area_id: UUID
        :param region: The STACKIT Region of the resources. (required)
        :type region: str
        :param routing_table_id: The identifier (ID) of a STACKIT Routing Table. (required)
        :type routing_table_id: UUID
        :param route_id: The identifier (ID) of a STACKIT Route. (required)
        :type route_id: UUID
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :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
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """  # noqa: E501

        _param = self._delete_route_from_routing_table_serialize(
            organization_id=organization_id,
            area_id=area_id,
            region=region,
            routing_table_id=routing_table_id,
            route_id=route_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "204": None,
            "400": "Error",
            "401": "Error",
            "403": "Error",
            "404": "Error",
            "500": "Error",
        }
        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data

    @validate_call
    def delete_route_from_routing_table_with_http_info(
        self,
        organization_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Organization.")],
        area_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Network Area.")],
        region: Annotated[StrictStr, Field(description="The STACKIT Region of the resources.")],
        routing_table_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Routing Table.")],
        route_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Route.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """Delete a route in a routing table.

        Delete a route in an existing routing table.

        :param organization_id: The identifier (ID) of a STACKIT Organization. (required)
        :type organization_id: UUID
        :param area_id: The identifier (ID) of a STACKIT Network Area. (required)
        :type area_id: UUID
        :param region: The STACKIT Region of the resources. (required)
        :type region: str
        :param routing_table_id: The identifier (ID) of a STACKIT Routing Table. (required)
        :type routing_table_id: UUID
        :param route_id: The identifier (ID) of a STACKIT Route. (required)
        :type route_id: UUID
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :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
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """  # noqa: E501

        _param = self._delete_route_from_routing_table_serialize(
            organization_id=organization_id,
            area_id=area_id,
            region=region,
            routing_table_id=routing_table_id,
            route_id=route_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "204": None,
            "400": "Error",
            "401": "Error",
            "403": "Error",
            "404": "Error",
            "500": "Error",
        }
        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )

    @validate_call
    def delete_route_from_routing_table_without_preload_content(
        self,
        organization_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Organization.")],
        area_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Network Area.")],
        region: Annotated[StrictStr, Field(description="The STACKIT Region of the resources.")],
        routing_table_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Routing Table.")],
        route_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Route.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Delete a route in a routing table.

        Delete a route in an existing routing table.

        :param organization_id: The identifier (ID) of a STACKIT Organization. (required)
        :type organization_id: UUID
        :param area_id: The identifier (ID) of a STACKIT Network Area. (required)
        :type area_id: UUID
        :param region: The STACKIT Region of the resources. (required)
        :type region: str
        :param routing_table_id: The identifier (ID) of a STACKIT Routing Table. (required)
        :type routing_table_id: UUID
        :param route_id: The identifier (ID) of a STACKIT Route. (required)
        :type route_id: UUID
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :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
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """  # noqa: E501

        _param = self._delete_route_from_routing_table_serialize(
            organization_id=organization_id,
            area_id=area_id,
            region=region,
            routing_table_id=routing_table_id,
            route_id=route_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "204": None,
            "400": "Error",
            "401": "Error",
            "403": "Error",
            "404": "Error",
            "500": "Error",
        }
        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
        return response_data.response

    def _delete_route_from_routing_table_serialize(
        self,
        organization_id,
        area_id,
        region,
        routing_table_id,
        route_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {}

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if organization_id is not None:
            _path_params["organizationId"] = organization_id
        if area_id is not None:
            _path_params["areaId"] = area_id
        if region is not None:
            _path_params["region"] = region
        if routing_table_id is not None:
            _path_params["routingTableId"] = routing_table_id
        if route_id is not None:
            _path_params["routeId"] = route_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter

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

        # authentication setting
        _auth_settings: List[str] = []

        return self.api_client.param_serialize(
            method="DELETE",
            resource_path="/v2alpha1/organizations/{organizationId}/network-areas/{areaId}/regions/{region}/routing-tables/{routingTableId}/routes/{routeId}",
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth,
        )

    @validate_call
    def delete_routing_table_from_area(
        self,
        organization_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Organization.")],
        area_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Network Area.")],
        region: Annotated[StrictStr, Field(description="The STACKIT Region of the resources.")],
        routing_table_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Routing Table.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """Delete a routing table.

        Delete a routing table of a network area.

        :param organization_id: The identifier (ID) of a STACKIT Organization. (required)
        :type organization_id: UUID
        :param area_id: The identifier (ID) of a STACKIT Network Area. (required)
        :type area_id: UUID
        :param region: The STACKIT Region of the resources. (required)
        :type region: str
        :param routing_table_id: The identifier (ID) of a STACKIT Routing Table. (required)
        :type routing_table_id: UUID
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :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
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """  # noqa: E501

        _param = self._delete_routing_table_from_area_serialize(
            organization_id=organization_id,
            area_id=area_id,
            region=region,
            routing_table_id=routing_table_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "204": None,
            "400": "Error",
            "401": "Error",
            "403": "Error",
            "404": "Error",
            "500": "Error",
        }
        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data

    @validate_call
    def delete_routing_table_from_area_with_http_info(
        self,
        organization_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Organization.")],
        area_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Network Area.")],
        region: Annotated[StrictStr, Field(description="The STACKIT Region of the resources.")],
        routing_table_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Routing Table.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """Delete a routing table.

        Delete a routing table of a network area.

        :param organization_id: The identifier (ID) of a STACKIT Organization. (required)
        :type organization_id: UUID
        :param area_id: The identifier (ID) of a STACKIT Network Area. (required)
        :type area_id: UUID
        :param region: The STACKIT Region of the resources. (required)
        :type region: str
        :param routing_table_id: The identifier (ID) of a STACKIT Routing Table. (required)
        :type routing_table_id: UUID
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :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
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """  # noqa: E501

        _param = self._delete_routing_table_from_area_serialize(
            organization_id=organization_id,
            area_id=area_id,
            region=region,
            routing_table_id=routing_table_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "204": None,
            "400": "Error",
            "401": "Error",
            "403": "Error",
            "404": "Error",
            "500": "Error",
        }
        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )

    @validate_call
    def delete_routing_table_from_area_without_preload_content(
        self,
        organization_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Organization.")],
        area_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Network Area.")],
        region: Annotated[StrictStr, Field(description="The STACKIT Region of the resources.")],
        routing_table_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Routing Table.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Delete a routing table.

        Delete a routing table of a network area.

        :param organization_id: The identifier (ID) of a STACKIT Organization. (required)
        :type organization_id: UUID
        :param area_id: The identifier (ID) of a STACKIT Network Area. (required)
        :type area_id: UUID
        :param region: The STACKIT Region of the resources. (required)
        :type region: str
        :param routing_table_id: The identifier (ID) of a STACKIT Routing Table. (required)
        :type routing_table_id: UUID
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :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
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """  # noqa: E501

        _param = self._delete_routing_table_from_area_serialize(
            organization_id=organization_id,
            area_id=area_id,
            region=region,
            routing_table_id=routing_table_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "204": None,
            "400": "Error",
            "401": "Error",
            "403": "Error",
            "404": "Error",
            "500": "Error",
        }
        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
        return response_data.response

    def _delete_routing_table_from_area_serialize(
        self,
        organization_id,
        area_id,
        region,
        routing_table_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {}

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if organization_id is not None:
            _path_params["organizationId"] = organization_id
        if area_id is not None:
            _path_params["areaId"] = area_id
        if region is not None:
            _path_params["region"] = region
        if routing_table_id is not None:
            _path_params["routingTableId"] = routing_table_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter

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

        # authentication setting
        _auth_settings: List[str] = []

        return self.api_client.param_serialize(
            method="DELETE",
            resource_path="/v2alpha1/organizations/{organizationId}/network-areas/{areaId}/regions/{region}/routing-tables/{routingTableId}",
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth,
        )

    @validate_call
    def get_network(
        self,
        project_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Project.")],
        region: Annotated[StrictStr, Field(description="The STACKIT Region of the resources.")],
        network_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Network.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> Network:
        """Get network details.

        Get details about a network of a project.

        :param project_id: The identifier (ID) of a STACKIT Project. (required)
        :type project_id: UUID
        :param region: The STACKIT Region of the resources. (required)
        :type region: str
        :param network_id: The identifier (ID) of a STACKIT Network. (required)
        :type network_id: UUID
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :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
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """  # noqa: E501

        _param = self._get_network_serialize(
            project_id=project_id,
            region=region,
            network_id=network_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "200": "Network",
            "400": "Error",
            "401": "Error",
            "403": "Error",
            "404": "Error",
            "500": "Error",
        }
        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data

    @validate_call
    def get_network_with_http_info(
        self,
        project_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Project.")],
        region: Annotated[StrictStr, Field(description="The STACKIT Region of the resources.")],
        network_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Network.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[Network]:
        """Get network details.

        Get details about a network of a project.

        :param project_id: The identifier (ID) of a STACKIT Project. (required)
        :type project_id: UUID
        :param region: The STACKIT Region of the resources. (required)
        :type region: str
        :param network_id: The identifier (ID) of a STACKIT Network. (required)
        :type network_id: UUID
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :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
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """  # noqa: E501

        _param = self._get_network_serialize(
            project_id=project_id,
            region=region,
            network_id=network_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "200": "Network",
            "400": "Error",
            "401": "Error",
            "403": "Error",
            "404": "Error",
            "500": "Error",
        }
        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )

    @validate_call
    def get_network_without_preload_content(
        self,
        project_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Project.")],
        region: Annotated[StrictStr, Field(description="The STACKIT Region of the resources.")],
        network_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Network.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Get network details.

        Get details about a network of a project.

        :param project_id: The identifier (ID) of a STACKIT Project. (required)
        :type project_id: UUID
        :param region: The STACKIT Region of the resources. (required)
        :type region: str
        :param network_id: The identifier (ID) of a STACKIT Network. (required)
        :type network_id: UUID
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :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
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """  # noqa: E501

        _param = self._get_network_serialize(
            project_id=project_id,
            region=region,
            network_id=network_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "200": "Network",
            "400": "Error",
            "401": "Error",
            "403": "Error",
            "404": "Error",
            "500": "Error",
        }
        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
        return response_data.response

    def _get_network_serialize(
        self,
        project_id,
        region,
        network_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {}

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params["projectId"] = project_id
        if region is not None:
            _path_params["region"] = region
        if network_id is not None:
            _path_params["networkId"] = network_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter

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

        # authentication setting
        _auth_settings: List[str] = []

        return self.api_client.param_serialize(
            method="GET",
            resource_path="/v2alpha1/projects/{projectId}/regions/{region}/networks/{networkId}",
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth,
        )

    @validate_call
    def get_route_of_routing_table(
        self,
        organization_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Organization.")],
        area_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Network Area.")],
        region: Annotated[StrictStr, Field(description="The STACKIT Region of the resources.")],
        routing_table_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Routing Table.")],
        route_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Route.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> Route:
        """Get details about a route of a routing table.

        Get details about a route defined in a routing table.

        :param organization_id: The identifier (ID) of a STACKIT Organization. (required)
        :type organization_id: UUID
        :param area_id: The identifier (ID) of a STACKIT Network Area. (required)
        :type area_id: UUID
        :param region: The STACKIT Region of the resources. (required)
        :type region: str
        :param routing_table_id: The identifier (ID) of a STACKIT Routing Table. (required)
        :type routing_table_id: UUID
        :param route_id: The identifier (ID) of a STACKIT Route. (required)
        :type route_id: UUID
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :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
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """  # noqa: E501

        _param = self._get_route_of_routing_table_serialize(
            organization_id=organization_id,
            area_id=area_id,
            region=region,
            routing_table_id=routing_table_id,
            route_id=route_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "200": "Route",
            "400": "Error",
            "401": "Error",
            "403": "Error",
            "404": "Error",
            "500": "Error",
        }
        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data

    @validate_call
    def get_route_of_routing_table_with_http_info(
        self,
        organization_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Organization.")],
        area_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Network Area.")],
        region: Annotated[StrictStr, Field(description="The STACKIT Region of the resources.")],
        routing_table_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Routing Table.")],
        route_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Route.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[Route]:
        """Get details about a route of a routing table.

        Get details about a route defined in a routing table.

        :param organization_id: The identifier (ID) of a STACKIT Organization. (required)
        :type organization_id: UUID
        :param area_id: The identifier (ID) of a STACKIT Network Area. (required)
        :type area_id: UUID
        :param region: The STACKIT Region of the resources. (required)
        :type region: str
        :param routing_table_id: The identifier (ID) of a STACKIT Routing Table. (required)
        :type routing_table_id: UUID
        :param route_id: The identifier (ID) of a STACKIT Route. (required)
        :type route_id: UUID
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :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
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """  # noqa: E501

        _param = self._get_route_of_routing_table_serialize(
            organization_id=organization_id,
            area_id=area_id,
            region=region,
            routing_table_id=routing_table_id,
            route_id=route_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "200": "Route",
            "400": "Error",
            "401": "Error",
            "403": "Error",
            "404": "Error",
            "500": "Error",
        }
        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )

    @validate_call
    def get_route_of_routing_table_without_preload_content(
        self,
        organization_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Organization.")],
        area_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Network Area.")],
        region: Annotated[StrictStr, Field(description="The STACKIT Region of the resources.")],
        routing_table_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Routing Table.")],
        route_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Route.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Get details about a route of a routing table.

        Get details about a route defined in a routing table.

        :param organization_id: The identifier (ID) of a STACKIT Organization. (required)
        :type organization_id: UUID
        :param area_id: The identifier (ID) of a STACKIT Network Area. (required)
        :type area_id: UUID
        :param region: The STACKIT Region of the resources. (required)
        :type region: str
        :param routing_table_id: The identifier (ID) of a STACKIT Routing Table. (required)
        :type routing_table_id: UUID
        :param route_id: The identifier (ID) of a STACKIT Route. (required)
        :type route_id: UUID
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :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
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """  # noqa: E501

        _param = self._get_route_of_routing_table_serialize(
            organization_id=organization_id,
            area_id=area_id,
            region=region,
            routing_table_id=routing_table_id,
            route_id=route_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "200": "Route",
            "400": "Error",
            "401": "Error",
            "403": "Error",
            "404": "Error",
            "500": "Error",
        }
        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
        return response_data.response

    def _get_route_of_routing_table_serialize(
        self,
        organization_id,
        area_id,
        region,
        routing_table_id,
        route_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {}

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if organization_id is not None:
            _path_params["organizationId"] = organization_id
        if area_id is not None:
            _path_params["areaId"] = area_id
        if region is not None:
            _path_params["region"] = region
        if routing_table_id is not None:
            _path_params["routingTableId"] = routing_table_id
        if route_id is not None:
            _path_params["routeId"] = route_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter

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

        # authentication setting
        _auth_settings: List[str] = []

        return self.api_client.param_serialize(
            method="GET",
            resource_path="/v2alpha1/organizations/{organizationId}/network-areas/{areaId}/regions/{region}/routing-tables/{routingTableId}/routes/{routeId}",
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth,
        )

    @validate_call
    def get_routing_table_of_area(
        self,
        organization_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Organization.")],
        area_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Network Area.")],
        region: Annotated[StrictStr, Field(description="The STACKIT Region of the resources.")],
        routing_table_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Routing Table.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RoutingTable:
        """Get details about a routing table.

        Get details about a routing table defined in a network area.

        :param organization_id: The identifier (ID) of a STACKIT Organization. (required)
        :type organization_id: UUID
        :param area_id: The identifier (ID) of a STACKIT Network Area. (required)
        :type area_id: UUID
        :param region: The STACKIT Region of the resources. (required)
        :type region: str
        :param routing_table_id: The identifier (ID) of a STACKIT Routing Table. (required)
        :type routing_table_id: UUID
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :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
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """  # noqa: E501

        _param = self._get_routing_table_of_area_serialize(
            organization_id=organization_id,
            area_id=area_id,
            region=region,
            routing_table_id=routing_table_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "200": "RoutingTable",
            "400": "Error",
            "401": "Error",
            "403": "Error",
            "404": "Error",
            "500": "Error",
        }
        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data

    @validate_call
    def get_routing_table_of_area_with_http_info(
        self,
        organization_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Organization.")],
        area_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Network Area.")],
        region: Annotated[StrictStr, Field(description="The STACKIT Region of the resources.")],
        routing_table_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Routing Table.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[RoutingTable]:
        """Get details about a routing table.

        Get details about a routing table defined in a network area.

        :param organization_id: The identifier (ID) of a STACKIT Organization. (required)
        :type organization_id: UUID
        :param area_id: The identifier (ID) of a STACKIT Network Area. (required)
        :type area_id: UUID
        :param region: The STACKIT Region of the resources. (required)
        :type region: str
        :param routing_table_id: The identifier (ID) of a STACKIT Routing Table. (required)
        :type routing_table_id: UUID
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :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
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """  # noqa: E501

        _param = self._get_routing_table_of_area_serialize(
            organization_id=organization_id,
            area_id=area_id,
            region=region,
            routing_table_id=routing_table_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "200": "RoutingTable",
            "400": "Error",
            "401": "Error",
            "403": "Error",
            "404": "Error",
            "500": "Error",
        }
        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )

    @validate_call
    def get_routing_table_of_area_without_preload_content(
        self,
        organization_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Organization.")],
        area_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Network Area.")],
        region: Annotated[StrictStr, Field(description="The STACKIT Region of the resources.")],
        routing_table_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Routing Table.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Get details about a routing table.

        Get details about a routing table defined in a network area.

        :param organization_id: The identifier (ID) of a STACKIT Organization. (required)
        :type organization_id: UUID
        :param area_id: The identifier (ID) of a STACKIT Network Area. (required)
        :type area_id: UUID
        :param region: The STACKIT Region of the resources. (required)
        :type region: str
        :param routing_table_id: The identifier (ID) of a STACKIT Routing Table. (required)
        :type routing_table_id: UUID
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :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
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """  # noqa: E501

        _param = self._get_routing_table_of_area_serialize(
            organization_id=organization_id,
            area_id=area_id,
            region=region,
            routing_table_id=routing_table_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "200": "RoutingTable",
            "400": "Error",
            "401": "Error",
            "403": "Error",
            "404": "Error",
            "500": "Error",
        }
        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
        return response_data.response

    def _get_routing_table_of_area_serialize(
        self,
        organization_id,
        area_id,
        region,
        routing_table_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {}

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if organization_id is not None:
            _path_params["organizationId"] = organization_id
        if area_id is not None:
            _path_params["areaId"] = area_id
        if region is not None:
            _path_params["region"] = region
        if routing_table_id is not None:
            _path_params["routingTableId"] = routing_table_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter

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

        # authentication setting
        _auth_settings: List[str] = []

        return self.api_client.param_serialize(
            method="GET",
            resource_path="/v2alpha1/organizations/{organizationId}/network-areas/{areaId}/regions/{region}/routing-tables/{routingTableId}",
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth,
        )

    @validate_call
    def list_networks(
        self,
        project_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Project.")],
        region: Annotated[StrictStr, Field(description="The STACKIT Region of the resources.")],
        label_selector: Annotated[Optional[StrictStr], Field(description="Filter resources by labels.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> NetworkListResponse:
        """List all networks inside a project.

        Get a list of all networks inside a project.

        :param project_id: The identifier (ID) of a STACKIT Project. (required)
        :type project_id: UUID
        :param region: The STACKIT Region of the resources. (required)
        :type region: str
        :param label_selector: Filter resources by labels.
        :type label_selector: 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.
        :type _request_timeout: int, tuple(int, int), optional
        :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
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """  # noqa: E501

        _param = self._list_networks_serialize(
            project_id=project_id,
            region=region,
            label_selector=label_selector,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "200": "NetworkListResponse",
            "400": "Error",
            "401": "Error",
            "403": "Error",
            "404": "Error",
            "500": "Error",
        }
        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data

    @validate_call
    def list_networks_with_http_info(
        self,
        project_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Project.")],
        region: Annotated[StrictStr, Field(description="The STACKIT Region of the resources.")],
        label_selector: Annotated[Optional[StrictStr], Field(description="Filter resources by labels.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[NetworkListResponse]:
        """List all networks inside a project.

        Get a list of all networks inside a project.

        :param project_id: The identifier (ID) of a STACKIT Project. (required)
        :type project_id: UUID
        :param region: The STACKIT Region of the resources. (required)
        :type region: str
        :param label_selector: Filter resources by labels.
        :type label_selector: 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.
        :type _request_timeout: int, tuple(int, int), optional
        :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
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """  # noqa: E501

        _param = self._list_networks_serialize(
            project_id=project_id,
            region=region,
            label_selector=label_selector,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "200": "NetworkListResponse",
            "400": "Error",
            "401": "Error",
            "403": "Error",
            "404": "Error",
            "500": "Error",
        }
        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )

    @validate_call
    def list_networks_without_preload_content(
        self,
        project_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Project.")],
        region: Annotated[StrictStr, Field(description="The STACKIT Region of the resources.")],
        label_selector: Annotated[Optional[StrictStr], Field(description="Filter resources by labels.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """List all networks inside a project.

        Get a list of all networks inside a project.

        :param project_id: The identifier (ID) of a STACKIT Project. (required)
        :type project_id: UUID
        :param region: The STACKIT Region of the resources. (required)
        :type region: str
        :param label_selector: Filter resources by labels.
        :type label_selector: 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.
        :type _request_timeout: int, tuple(int, int), optional
        :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
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """  # noqa: E501

        _param = self._list_networks_serialize(
            project_id=project_id,
            region=region,
            label_selector=label_selector,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "200": "NetworkListResponse",
            "400": "Error",
            "401": "Error",
            "403": "Error",
            "404": "Error",
            "500": "Error",
        }
        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
        return response_data.response

    def _list_networks_serialize(
        self,
        project_id,
        region,
        label_selector,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {}

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params["projectId"] = project_id
        if region is not None:
            _path_params["region"] = region
        # process the query parameters
        if label_selector is not None:

            _query_params.append(("label_selector", label_selector))

        # process the header parameters
        # process the form parameters
        # process the body parameter

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

        # authentication setting
        _auth_settings: List[str] = []

        return self.api_client.param_serialize(
            method="GET",
            resource_path="/v2alpha1/projects/{projectId}/regions/{region}/networks",
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth,
        )

    @validate_call
    def list_networks_of_routing_table(
        self,
        organization_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Organization.")],
        area_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Network Area.")],
        region: Annotated[StrictStr, Field(description="The STACKIT Region of the resources.")],
        routing_table_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Routing Table.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> NetworkListResponse:
        """List all networks in a routing table.

        Get a list of all networks in a routing table.

        :param organization_id: The identifier (ID) of a STACKIT Organization. (required)
        :type organization_id: UUID
        :param area_id: The identifier (ID) of a STACKIT Network Area. (required)
        :type area_id: UUID
        :param region: The STACKIT Region of the resources. (required)
        :type region: str
        :param routing_table_id: The identifier (ID) of a STACKIT Routing Table. (required)
        :type routing_table_id: UUID
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :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
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """  # noqa: E501

        _param = self._list_networks_of_routing_table_serialize(
            organization_id=organization_id,
            area_id=area_id,
            region=region,
            routing_table_id=routing_table_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "200": "NetworkListResponse",
            "400": "Error",
            "401": "Error",
            "403": "Error",
            "404": "Error",
            "500": "Error",
        }
        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data

    @validate_call
    def list_networks_of_routing_table_with_http_info(
        self,
        organization_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Organization.")],
        area_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Network Area.")],
        region: Annotated[StrictStr, Field(description="The STACKIT Region of the resources.")],
        routing_table_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Routing Table.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[NetworkListResponse]:
        """List all networks in a routing table.

        Get a list of all networks in a routing table.

        :param organization_id: The identifier (ID) of a STACKIT Organization. (required)
        :type organization_id: UUID
        :param area_id: The identifier (ID) of a STACKIT Network Area. (required)
        :type area_id: UUID
        :param region: The STACKIT Region of the resources. (required)
        :type region: str
        :param routing_table_id: The identifier (ID) of a STACKIT Routing Table. (required)
        :type routing_table_id: UUID
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :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
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """  # noqa: E501

        _param = self._list_networks_of_routing_table_serialize(
            organization_id=organization_id,
            area_id=area_id,
            region=region,
            routing_table_id=routing_table_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "200": "NetworkListResponse",
            "400": "Error",
            "401": "Error",
            "403": "Error",
            "404": "Error",
            "500": "Error",
        }
        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )

    @validate_call
    def list_networks_of_routing_table_without_preload_content(
        self,
        organization_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Organization.")],
        area_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Network Area.")],
        region: Annotated[StrictStr, Field(description="The STACKIT Region of the resources.")],
        routing_table_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Routing Table.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """List all networks in a routing table.

        Get a list of all networks in a routing table.

        :param organization_id: The identifier (ID) of a STACKIT Organization. (required)
        :type organization_id: UUID
        :param area_id: The identifier (ID) of a STACKIT Network Area. (required)
        :type area_id: UUID
        :param region: The STACKIT Region of the resources. (required)
        :type region: str
        :param routing_table_id: The identifier (ID) of a STACKIT Routing Table. (required)
        :type routing_table_id: UUID
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :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
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """  # noqa: E501

        _param = self._list_networks_of_routing_table_serialize(
            organization_id=organization_id,
            area_id=area_id,
            region=region,
            routing_table_id=routing_table_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "200": "NetworkListResponse",
            "400": "Error",
            "401": "Error",
            "403": "Error",
            "404": "Error",
            "500": "Error",
        }
        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
        return response_data.response

    def _list_networks_of_routing_table_serialize(
        self,
        organization_id,
        area_id,
        region,
        routing_table_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {}

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if organization_id is not None:
            _path_params["organizationId"] = organization_id
        if area_id is not None:
            _path_params["areaId"] = area_id
        if region is not None:
            _path_params["region"] = region
        if routing_table_id is not None:
            _path_params["routingTableId"] = routing_table_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter

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

        # authentication setting
        _auth_settings: List[str] = []

        return self.api_client.param_serialize(
            method="GET",
            resource_path="/v2alpha1/organizations/{organizationId}/network-areas/{areaId}/regions/{region}/routing-tables/{routingTableId}/networks",
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth,
        )

    @validate_call
    def list_routes_of_routing_table(
        self,
        organization_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Organization.")],
        area_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Network Area.")],
        region: Annotated[StrictStr, Field(description="The STACKIT Region of the resources.")],
        routing_table_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Routing Table.")],
        label_selector: Annotated[Optional[StrictStr], Field(description="Filter resources by labels.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RouteListResponse:
        """List all routes in a routing table.

        Get a list of all routes in a routing table.

        :param organization_id: The identifier (ID) of a STACKIT Organization. (required)
        :type organization_id: UUID
        :param area_id: The identifier (ID) of a STACKIT Network Area. (required)
        :type area_id: UUID
        :param region: The STACKIT Region of the resources. (required)
        :type region: str
        :param routing_table_id: The identifier (ID) of a STACKIT Routing Table. (required)
        :type routing_table_id: UUID
        :param label_selector: Filter resources by labels.
        :type label_selector: 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.
        :type _request_timeout: int, tuple(int, int), optional
        :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
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """  # noqa: E501

        _param = self._list_routes_of_routing_table_serialize(
            organization_id=organization_id,
            area_id=area_id,
            region=region,
            routing_table_id=routing_table_id,
            label_selector=label_selector,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "200": "RouteListResponse",
            "400": "Error",
            "401": "Error",
            "403": "Error",
            "404": "Error",
            "500": "Error",
        }
        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data

    @validate_call
    def list_routes_of_routing_table_with_http_info(
        self,
        organization_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Organization.")],
        area_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Network Area.")],
        region: Annotated[StrictStr, Field(description="The STACKIT Region of the resources.")],
        routing_table_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Routing Table.")],
        label_selector: Annotated[Optional[StrictStr], Field(description="Filter resources by labels.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[RouteListResponse]:
        """List all routes in a routing table.

        Get a list of all routes in a routing table.

        :param organization_id: The identifier (ID) of a STACKIT Organization. (required)
        :type organization_id: UUID
        :param area_id: The identifier (ID) of a STACKIT Network Area. (required)
        :type area_id: UUID
        :param region: The STACKIT Region of the resources. (required)
        :type region: str
        :param routing_table_id: The identifier (ID) of a STACKIT Routing Table. (required)
        :type routing_table_id: UUID
        :param label_selector: Filter resources by labels.
        :type label_selector: 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.
        :type _request_timeout: int, tuple(int, int), optional
        :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
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """  # noqa: E501

        _param = self._list_routes_of_routing_table_serialize(
            organization_id=organization_id,
            area_id=area_id,
            region=region,
            routing_table_id=routing_table_id,
            label_selector=label_selector,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "200": "RouteListResponse",
            "400": "Error",
            "401": "Error",
            "403": "Error",
            "404": "Error",
            "500": "Error",
        }
        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )

    @validate_call
    def list_routes_of_routing_table_without_preload_content(
        self,
        organization_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Organization.")],
        area_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Network Area.")],
        region: Annotated[StrictStr, Field(description="The STACKIT Region of the resources.")],
        routing_table_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Routing Table.")],
        label_selector: Annotated[Optional[StrictStr], Field(description="Filter resources by labels.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """List all routes in a routing table.

        Get a list of all routes in a routing table.

        :param organization_id: The identifier (ID) of a STACKIT Organization. (required)
        :type organization_id: UUID
        :param area_id: The identifier (ID) of a STACKIT Network Area. (required)
        :type area_id: UUID
        :param region: The STACKIT Region of the resources. (required)
        :type region: str
        :param routing_table_id: The identifier (ID) of a STACKIT Routing Table. (required)
        :type routing_table_id: UUID
        :param label_selector: Filter resources by labels.
        :type label_selector: 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.
        :type _request_timeout: int, tuple(int, int), optional
        :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
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """  # noqa: E501

        _param = self._list_routes_of_routing_table_serialize(
            organization_id=organization_id,
            area_id=area_id,
            region=region,
            routing_table_id=routing_table_id,
            label_selector=label_selector,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "200": "RouteListResponse",
            "400": "Error",
            "401": "Error",
            "403": "Error",
            "404": "Error",
            "500": "Error",
        }
        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
        return response_data.response

    def _list_routes_of_routing_table_serialize(
        self,
        organization_id,
        area_id,
        region,
        routing_table_id,
        label_selector,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {}

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if organization_id is not None:
            _path_params["organizationId"] = organization_id
        if area_id is not None:
            _path_params["areaId"] = area_id
        if region is not None:
            _path_params["region"] = region
        if routing_table_id is not None:
            _path_params["routingTableId"] = routing_table_id
        # process the query parameters
        if label_selector is not None:

            _query_params.append(("label_selector", label_selector))

        # process the header parameters
        # process the form parameters
        # process the body parameter

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

        # authentication setting
        _auth_settings: List[str] = []

        return self.api_client.param_serialize(
            method="GET",
            resource_path="/v2alpha1/organizations/{organizationId}/network-areas/{areaId}/regions/{region}/routing-tables/{routingTableId}/routes",
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth,
        )

    @validate_call
    def list_routing_tables_of_area(
        self,
        organization_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Organization.")],
        area_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Network Area.")],
        region: Annotated[StrictStr, Field(description="The STACKIT Region of the resources.")],
        label_selector: Annotated[Optional[StrictStr], Field(description="Filter resources by labels.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RoutingTableListResponse:
        """List all routing tables in a network area.

        Get a list of all routing tables in a network area.

        :param organization_id: The identifier (ID) of a STACKIT Organization. (required)
        :type organization_id: UUID
        :param area_id: The identifier (ID) of a STACKIT Network Area. (required)
        :type area_id: UUID
        :param region: The STACKIT Region of the resources. (required)
        :type region: str
        :param label_selector: Filter resources by labels.
        :type label_selector: 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.
        :type _request_timeout: int, tuple(int, int), optional
        :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
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """  # noqa: E501

        _param = self._list_routing_tables_of_area_serialize(
            organization_id=organization_id,
            area_id=area_id,
            region=region,
            label_selector=label_selector,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "200": "RoutingTableListResponse",
            "400": "Error",
            "401": "Error",
            "403": "Error",
            "404": "Error",
            "500": "Error",
        }
        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data

    @validate_call
    def list_routing_tables_of_area_with_http_info(
        self,
        organization_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Organization.")],
        area_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Network Area.")],
        region: Annotated[StrictStr, Field(description="The STACKIT Region of the resources.")],
        label_selector: Annotated[Optional[StrictStr], Field(description="Filter resources by labels.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[RoutingTableListResponse]:
        """List all routing tables in a network area.

        Get a list of all routing tables in a network area.

        :param organization_id: The identifier (ID) of a STACKIT Organization. (required)
        :type organization_id: UUID
        :param area_id: The identifier (ID) of a STACKIT Network Area. (required)
        :type area_id: UUID
        :param region: The STACKIT Region of the resources. (required)
        :type region: str
        :param label_selector: Filter resources by labels.
        :type label_selector: 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.
        :type _request_timeout: int, tuple(int, int), optional
        :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
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """  # noqa: E501

        _param = self._list_routing_tables_of_area_serialize(
            organization_id=organization_id,
            area_id=area_id,
            region=region,
            label_selector=label_selector,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "200": "RoutingTableListResponse",
            "400": "Error",
            "401": "Error",
            "403": "Error",
            "404": "Error",
            "500": "Error",
        }
        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )

    @validate_call
    def list_routing_tables_of_area_without_preload_content(
        self,
        organization_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Organization.")],
        area_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Network Area.")],
        region: Annotated[StrictStr, Field(description="The STACKIT Region of the resources.")],
        label_selector: Annotated[Optional[StrictStr], Field(description="Filter resources by labels.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """List all routing tables in a network area.

        Get a list of all routing tables in a network area.

        :param organization_id: The identifier (ID) of a STACKIT Organization. (required)
        :type organization_id: UUID
        :param area_id: The identifier (ID) of a STACKIT Network Area. (required)
        :type area_id: UUID
        :param region: The STACKIT Region of the resources. (required)
        :type region: str
        :param label_selector: Filter resources by labels.
        :type label_selector: 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.
        :type _request_timeout: int, tuple(int, int), optional
        :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
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """  # noqa: E501

        _param = self._list_routing_tables_of_area_serialize(
            organization_id=organization_id,
            area_id=area_id,
            region=region,
            label_selector=label_selector,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "200": "RoutingTableListResponse",
            "400": "Error",
            "401": "Error",
            "403": "Error",
            "404": "Error",
            "500": "Error",
        }
        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
        return response_data.response

    def _list_routing_tables_of_area_serialize(
        self,
        organization_id,
        area_id,
        region,
        label_selector,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {}

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if organization_id is not None:
            _path_params["organizationId"] = organization_id
        if area_id is not None:
            _path_params["areaId"] = area_id
        if region is not None:
            _path_params["region"] = region
        # process the query parameters
        if label_selector is not None:

            _query_params.append(("label_selector", label_selector))

        # process the header parameters
        # process the form parameters
        # process the body parameter

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

        # authentication setting
        _auth_settings: List[str] = []

        return self.api_client.param_serialize(
            method="GET",
            resource_path="/v2alpha1/organizations/{organizationId}/network-areas/{areaId}/regions/{region}/routing-tables",
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth,
        )

    @validate_call
    def partial_update_network(
        self,
        project_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Project.")],
        region: Annotated[StrictStr, Field(description="The STACKIT Region of the resources.")],
        network_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Network.")],
        partial_update_network_payload: Annotated[
            PartialUpdateNetworkPayload, Field(description="Request an update of a network.")
        ],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """Update network settings.

        Update the settings of a network inside a project.

        :param project_id: The identifier (ID) of a STACKIT Project. (required)
        :type project_id: UUID
        :param region: The STACKIT Region of the resources. (required)
        :type region: str
        :param network_id: The identifier (ID) of a STACKIT Network. (required)
        :type network_id: UUID
        :param partial_update_network_payload: Request an update of a network. (required)
        :type partial_update_network_payload: PartialUpdateNetworkPayload
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :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
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """  # noqa: E501

        _param = self._partial_update_network_serialize(
            project_id=project_id,
            region=region,
            network_id=network_id,
            partial_update_network_payload=partial_update_network_payload,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "202": None,
            "400": "Error",
            "401": "Error",
            "403": "Error",
            "404": "Error",
            "500": "Error",
        }
        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data

    @validate_call
    def partial_update_network_with_http_info(
        self,
        project_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Project.")],
        region: Annotated[StrictStr, Field(description="The STACKIT Region of the resources.")],
        network_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Network.")],
        partial_update_network_payload: Annotated[
            PartialUpdateNetworkPayload, Field(description="Request an update of a network.")
        ],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """Update network settings.

        Update the settings of a network inside a project.

        :param project_id: The identifier (ID) of a STACKIT Project. (required)
        :type project_id: UUID
        :param region: The STACKIT Region of the resources. (required)
        :type region: str
        :param network_id: The identifier (ID) of a STACKIT Network. (required)
        :type network_id: UUID
        :param partial_update_network_payload: Request an update of a network. (required)
        :type partial_update_network_payload: PartialUpdateNetworkPayload
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :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
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """  # noqa: E501

        _param = self._partial_update_network_serialize(
            project_id=project_id,
            region=region,
            network_id=network_id,
            partial_update_network_payload=partial_update_network_payload,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "202": None,
            "400": "Error",
            "401": "Error",
            "403": "Error",
            "404": "Error",
            "500": "Error",
        }
        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )

    @validate_call
    def partial_update_network_without_preload_content(
        self,
        project_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Project.")],
        region: Annotated[StrictStr, Field(description="The STACKIT Region of the resources.")],
        network_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Network.")],
        partial_update_network_payload: Annotated[
            PartialUpdateNetworkPayload, Field(description="Request an update of a network.")
        ],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Update network settings.

        Update the settings of a network inside a project.

        :param project_id: The identifier (ID) of a STACKIT Project. (required)
        :type project_id: UUID
        :param region: The STACKIT Region of the resources. (required)
        :type region: str
        :param network_id: The identifier (ID) of a STACKIT Network. (required)
        :type network_id: UUID
        :param partial_update_network_payload: Request an update of a network. (required)
        :type partial_update_network_payload: PartialUpdateNetworkPayload
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :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
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """  # noqa: E501

        _param = self._partial_update_network_serialize(
            project_id=project_id,
            region=region,
            network_id=network_id,
            partial_update_network_payload=partial_update_network_payload,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "202": None,
            "400": "Error",
            "401": "Error",
            "403": "Error",
            "404": "Error",
            "500": "Error",
        }
        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
        return response_data.response

    def _partial_update_network_serialize(
        self,
        project_id,
        region,
        network_id,
        partial_update_network_payload,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {}

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params["projectId"] = project_id
        if region is not None:
            _path_params["region"] = region
        if network_id is not None:
            _path_params["networkId"] = network_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if partial_update_network_payload is not None:
            _body_params = partial_update_network_payload

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

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params["Content-Type"] = _content_type
        else:
            _default_content_type = self.api_client.select_header_content_type(["application/json"])
            if _default_content_type is not None:
                _header_params["Content-Type"] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = []

        return self.api_client.param_serialize(
            method="PATCH",
            resource_path="/v2alpha1/projects/{projectId}/regions/{region}/networks/{networkId}",
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth,
        )

    @validate_call
    def update_route_of_routing_table(
        self,
        organization_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Organization.")],
        area_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Network Area.")],
        region: Annotated[StrictStr, Field(description="The STACKIT Region of the resources.")],
        routing_table_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Routing Table.")],
        route_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Route.")],
        update_route_of_routing_table_payload: Annotated[
            UpdateRouteOfRoutingTablePayload, Field(description="Request an update of a route in a routing table.")
        ],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> Route:
        """Update a route of a routing table.

        Update a route defined in a routing table.

        :param organization_id: The identifier (ID) of a STACKIT Organization. (required)
        :type organization_id: UUID
        :param area_id: The identifier (ID) of a STACKIT Network Area. (required)
        :type area_id: UUID
        :param region: The STACKIT Region of the resources. (required)
        :type region: str
        :param routing_table_id: The identifier (ID) of a STACKIT Routing Table. (required)
        :type routing_table_id: UUID
        :param route_id: The identifier (ID) of a STACKIT Route. (required)
        :type route_id: UUID
        :param update_route_of_routing_table_payload: Request an update of a route in a routing table. (required)
        :type update_route_of_routing_table_payload: UpdateRouteOfRoutingTablePayload
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :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
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """  # noqa: E501

        _param = self._update_route_of_routing_table_serialize(
            organization_id=organization_id,
            area_id=area_id,
            region=region,
            routing_table_id=routing_table_id,
            route_id=route_id,
            update_route_of_routing_table_payload=update_route_of_routing_table_payload,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "200": "Route",
            "400": "Error",
            "401": "Error",
            "403": "Error",
            "404": "Error",
            "500": "Error",
        }
        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data

    @validate_call
    def update_route_of_routing_table_with_http_info(
        self,
        organization_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Organization.")],
        area_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Network Area.")],
        region: Annotated[StrictStr, Field(description="The STACKIT Region of the resources.")],
        routing_table_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Routing Table.")],
        route_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Route.")],
        update_route_of_routing_table_payload: Annotated[
            UpdateRouteOfRoutingTablePayload, Field(description="Request an update of a route in a routing table.")
        ],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[Route]:
        """Update a route of a routing table.

        Update a route defined in a routing table.

        :param organization_id: The identifier (ID) of a STACKIT Organization. (required)
        :type organization_id: UUID
        :param area_id: The identifier (ID) of a STACKIT Network Area. (required)
        :type area_id: UUID
        :param region: The STACKIT Region of the resources. (required)
        :type region: str
        :param routing_table_id: The identifier (ID) of a STACKIT Routing Table. (required)
        :type routing_table_id: UUID
        :param route_id: The identifier (ID) of a STACKIT Route. (required)
        :type route_id: UUID
        :param update_route_of_routing_table_payload: Request an update of a route in a routing table. (required)
        :type update_route_of_routing_table_payload: UpdateRouteOfRoutingTablePayload
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :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
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """  # noqa: E501

        _param = self._update_route_of_routing_table_serialize(
            organization_id=organization_id,
            area_id=area_id,
            region=region,
            routing_table_id=routing_table_id,
            route_id=route_id,
            update_route_of_routing_table_payload=update_route_of_routing_table_payload,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "200": "Route",
            "400": "Error",
            "401": "Error",
            "403": "Error",
            "404": "Error",
            "500": "Error",
        }
        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )

    @validate_call
    def update_route_of_routing_table_without_preload_content(
        self,
        organization_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Organization.")],
        area_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Network Area.")],
        region: Annotated[StrictStr, Field(description="The STACKIT Region of the resources.")],
        routing_table_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Routing Table.")],
        route_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Route.")],
        update_route_of_routing_table_payload: Annotated[
            UpdateRouteOfRoutingTablePayload, Field(description="Request an update of a route in a routing table.")
        ],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Update a route of a routing table.

        Update a route defined in a routing table.

        :param organization_id: The identifier (ID) of a STACKIT Organization. (required)
        :type organization_id: UUID
        :param area_id: The identifier (ID) of a STACKIT Network Area. (required)
        :type area_id: UUID
        :param region: The STACKIT Region of the resources. (required)
        :type region: str
        :param routing_table_id: The identifier (ID) of a STACKIT Routing Table. (required)
        :type routing_table_id: UUID
        :param route_id: The identifier (ID) of a STACKIT Route. (required)
        :type route_id: UUID
        :param update_route_of_routing_table_payload: Request an update of a route in a routing table. (required)
        :type update_route_of_routing_table_payload: UpdateRouteOfRoutingTablePayload
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :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
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """  # noqa: E501

        _param = self._update_route_of_routing_table_serialize(
            organization_id=organization_id,
            area_id=area_id,
            region=region,
            routing_table_id=routing_table_id,
            route_id=route_id,
            update_route_of_routing_table_payload=update_route_of_routing_table_payload,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "200": "Route",
            "400": "Error",
            "401": "Error",
            "403": "Error",
            "404": "Error",
            "500": "Error",
        }
        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
        return response_data.response

    def _update_route_of_routing_table_serialize(
        self,
        organization_id,
        area_id,
        region,
        routing_table_id,
        route_id,
        update_route_of_routing_table_payload,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {}

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if organization_id is not None:
            _path_params["organizationId"] = organization_id
        if area_id is not None:
            _path_params["areaId"] = area_id
        if region is not None:
            _path_params["region"] = region
        if routing_table_id is not None:
            _path_params["routingTableId"] = routing_table_id
        if route_id is not None:
            _path_params["routeId"] = route_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if update_route_of_routing_table_payload is not None:
            _body_params = update_route_of_routing_table_payload

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

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params["Content-Type"] = _content_type
        else:
            _default_content_type = self.api_client.select_header_content_type(["application/json"])
            if _default_content_type is not None:
                _header_params["Content-Type"] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = []

        return self.api_client.param_serialize(
            method="PATCH",
            resource_path="/v2alpha1/organizations/{organizationId}/network-areas/{areaId}/regions/{region}/routing-tables/{routingTableId}/routes/{routeId}",
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth,
        )

    @validate_call
    def update_routing_table_of_area(
        self,
        organization_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Organization.")],
        area_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Network Area.")],
        region: Annotated[StrictStr, Field(description="The STACKIT Region of the resources.")],
        routing_table_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Routing Table.")],
        update_routing_table_of_area_payload: Annotated[
            UpdateRoutingTableOfAreaPayload, Field(description="Request an update of a routing table.")
        ],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RoutingTable:
        """Update a routing table.

        Update a routing table defined in a network area.

        :param organization_id: The identifier (ID) of a STACKIT Organization. (required)
        :type organization_id: UUID
        :param area_id: The identifier (ID) of a STACKIT Network Area. (required)
        :type area_id: UUID
        :param region: The STACKIT Region of the resources. (required)
        :type region: str
        :param routing_table_id: The identifier (ID) of a STACKIT Routing Table. (required)
        :type routing_table_id: UUID
        :param update_routing_table_of_area_payload: Request an update of a routing table. (required)
        :type update_routing_table_of_area_payload: UpdateRoutingTableOfAreaPayload
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :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
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """  # noqa: E501

        _param = self._update_routing_table_of_area_serialize(
            organization_id=organization_id,
            area_id=area_id,
            region=region,
            routing_table_id=routing_table_id,
            update_routing_table_of_area_payload=update_routing_table_of_area_payload,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "200": "RoutingTable",
            "400": "Error",
            "401": "Error",
            "403": "Error",
            "404": "Error",
            "500": "Error",
        }
        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data

    @validate_call
    def update_routing_table_of_area_with_http_info(
        self,
        organization_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Organization.")],
        area_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Network Area.")],
        region: Annotated[StrictStr, Field(description="The STACKIT Region of the resources.")],
        routing_table_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Routing Table.")],
        update_routing_table_of_area_payload: Annotated[
            UpdateRoutingTableOfAreaPayload, Field(description="Request an update of a routing table.")
        ],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[RoutingTable]:
        """Update a routing table.

        Update a routing table defined in a network area.

        :param organization_id: The identifier (ID) of a STACKIT Organization. (required)
        :type organization_id: UUID
        :param area_id: The identifier (ID) of a STACKIT Network Area. (required)
        :type area_id: UUID
        :param region: The STACKIT Region of the resources. (required)
        :type region: str
        :param routing_table_id: The identifier (ID) of a STACKIT Routing Table. (required)
        :type routing_table_id: UUID
        :param update_routing_table_of_area_payload: Request an update of a routing table. (required)
        :type update_routing_table_of_area_payload: UpdateRoutingTableOfAreaPayload
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :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
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """  # noqa: E501

        _param = self._update_routing_table_of_area_serialize(
            organization_id=organization_id,
            area_id=area_id,
            region=region,
            routing_table_id=routing_table_id,
            update_routing_table_of_area_payload=update_routing_table_of_area_payload,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "200": "RoutingTable",
            "400": "Error",
            "401": "Error",
            "403": "Error",
            "404": "Error",
            "500": "Error",
        }
        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )

    @validate_call
    def update_routing_table_of_area_without_preload_content(
        self,
        organization_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Organization.")],
        area_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Network Area.")],
        region: Annotated[StrictStr, Field(description="The STACKIT Region of the resources.")],
        routing_table_id: Annotated[UUID, Field(description="The identifier (ID) of a STACKIT Routing Table.")],
        update_routing_table_of_area_payload: Annotated[
            UpdateRoutingTableOfAreaPayload, Field(description="Request an update of a routing table.")
        ],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Update a routing table.

        Update a routing table defined in a network area.

        :param organization_id: The identifier (ID) of a STACKIT Organization. (required)
        :type organization_id: UUID
        :param area_id: The identifier (ID) of a STACKIT Network Area. (required)
        :type area_id: UUID
        :param region: The STACKIT Region of the resources. (required)
        :type region: str
        :param routing_table_id: The identifier (ID) of a STACKIT Routing Table. (required)
        :type routing_table_id: UUID
        :param update_routing_table_of_area_payload: Request an update of a routing table. (required)
        :type update_routing_table_of_area_payload: UpdateRoutingTableOfAreaPayload
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :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
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """  # noqa: E501

        _param = self._update_routing_table_of_area_serialize(
            organization_id=organization_id,
            area_id=area_id,
            region=region,
            routing_table_id=routing_table_id,
            update_routing_table_of_area_payload=update_routing_table_of_area_payload,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index,
        )

        _response_types_map: Dict[str, Optional[str]] = {
            "200": "RoutingTable",
            "400": "Error",
            "401": "Error",
            "403": "Error",
            "404": "Error",
            "500": "Error",
        }
        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
        return response_data.response

    def _update_routing_table_of_area_serialize(
        self,
        organization_id,
        area_id,
        region,
        routing_table_id,
        update_routing_table_of_area_payload,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {}

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if organization_id is not None:
            _path_params["organizationId"] = organization_id
        if area_id is not None:
            _path_params["areaId"] = area_id
        if region is not None:
            _path_params["region"] = region
        if routing_table_id is not None:
            _path_params["routingTableId"] = routing_table_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if update_routing_table_of_area_payload is not None:
            _body_params = update_routing_table_of_area_payload

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

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params["Content-Type"] = _content_type
        else:
            _default_content_type = self.api_client.select_header_content_type(["application/json"])
            if _default_content_type is not None:
                _header_params["Content-Type"] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = []

        return self.api_client.param_serialize(
            method="PATCH",
            resource_path="/v2alpha1/organizations/{organizationId}/network-areas/{areaId}/regions/{region}/routing-tables/{routingTableId}",
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth,
        )