from __future__ import annotations

from openstatus._gen.openstatus.status_page.v1.service_pb2 import (
    AddMonitorComponentRequest,
    AddMonitorComponentResponse,
    AddStaticComponentRequest,
    AddStaticComponentResponse,
    CreateComponentGroupRequest,
    CreateComponentGroupResponse,
    CreatePageSubscriptionRequest,
    CreatePageSubscriptionResponse,
    CreateStatusPageRequest,
    CreateStatusPageResponse,
    DeleteComponentGroupRequest,
    DeleteComponentGroupResponse,
    DeleteStatusPageRequest,
    DeleteStatusPageResponse,
    GetOverallStatusRequest,
    GetOverallStatusResponse,
    GetStatusPageContentRequest,
    GetStatusPageContentResponse,
    GetStatusPageRequest,
    GetStatusPageResponse,
    ListStatusPagesRequest,
    ListStatusPagesResponse,
    ListSubscribersRequest,
    ListSubscribersResponse,
    RemoveComponentRequest,
    RemoveComponentResponse,
    SubscribeToPageRequest,
    SubscribeToPageResponse,
    UnsubscribeFromPageRequest,
    UnsubscribeFromPageResponse,
    UpdateComponentGroupRequest,
    UpdateComponentGroupResponse,
    UpdateComponentRequest,
    UpdateComponentResponse,
    UpdateStatusPageRequest,
    UpdateStatusPageResponse,
)
from openstatus._transport import _AsyncJsonTransport, _JsonTransport

__all__ = ["AsyncStatusPageServiceClient", "StatusPageServiceClient"]

_FQN = "openstatus.status_page.v1.StatusPageService"


class StatusPageServiceClient:
    def __init__(self, transport: _JsonTransport) -> None:
        self._t = transport

    def create_status_page(
        self,
        request: CreateStatusPageRequest,
        *,
        headers: dict[str, str] | None = None,
    ) -> CreateStatusPageResponse:
        return self._t.call(_FQN, "CreateStatusPage", request, CreateStatusPageResponse, headers)

    def get_status_page(
        self,
        request: GetStatusPageRequest,
        *,
        headers: dict[str, str] | None = None,
    ) -> GetStatusPageResponse:
        return self._t.call(_FQN, "GetStatusPage", request, GetStatusPageResponse, headers)

    def list_status_pages(
        self,
        request: ListStatusPagesRequest,
        *,
        headers: dict[str, str] | None = None,
    ) -> ListStatusPagesResponse:
        return self._t.call(_FQN, "ListStatusPages", request, ListStatusPagesResponse, headers)

    def update_status_page(
        self,
        request: UpdateStatusPageRequest,
        *,
        headers: dict[str, str] | None = None,
    ) -> UpdateStatusPageResponse:
        return self._t.call(_FQN, "UpdateStatusPage", request, UpdateStatusPageResponse, headers)

    def delete_status_page(
        self,
        request: DeleteStatusPageRequest,
        *,
        headers: dict[str, str] | None = None,
    ) -> DeleteStatusPageResponse:
        return self._t.call(_FQN, "DeleteStatusPage", request, DeleteStatusPageResponse, headers)

    def add_monitor_component(
        self,
        request: AddMonitorComponentRequest,
        *,
        headers: dict[str, str] | None = None,
    ) -> AddMonitorComponentResponse:
        return self._t.call(
            _FQN, "AddMonitorComponent", request, AddMonitorComponentResponse, headers
        )

    def add_static_component(
        self,
        request: AddStaticComponentRequest,
        *,
        headers: dict[str, str] | None = None,
    ) -> AddStaticComponentResponse:
        return self._t.call(
            _FQN, "AddStaticComponent", request, AddStaticComponentResponse, headers
        )

    def remove_component(
        self,
        request: RemoveComponentRequest,
        *,
        headers: dict[str, str] | None = None,
    ) -> RemoveComponentResponse:
        return self._t.call(_FQN, "RemoveComponent", request, RemoveComponentResponse, headers)

    def update_component(
        self,
        request: UpdateComponentRequest,
        *,
        headers: dict[str, str] | None = None,
    ) -> UpdateComponentResponse:
        return self._t.call(_FQN, "UpdateComponent", request, UpdateComponentResponse, headers)

    def create_component_group(
        self,
        request: CreateComponentGroupRequest,
        *,
        headers: dict[str, str] | None = None,
    ) -> CreateComponentGroupResponse:
        return self._t.call(
            _FQN, "CreateComponentGroup", request, CreateComponentGroupResponse, headers
        )

    def delete_component_group(
        self,
        request: DeleteComponentGroupRequest,
        *,
        headers: dict[str, str] | None = None,
    ) -> DeleteComponentGroupResponse:
        return self._t.call(
            _FQN, "DeleteComponentGroup", request, DeleteComponentGroupResponse, headers
        )

    def update_component_group(
        self,
        request: UpdateComponentGroupRequest,
        *,
        headers: dict[str, str] | None = None,
    ) -> UpdateComponentGroupResponse:
        return self._t.call(
            _FQN, "UpdateComponentGroup", request, UpdateComponentGroupResponse, headers
        )

    def subscribe_to_page(
        self,
        request: SubscribeToPageRequest,
        *,
        headers: dict[str, str] | None = None,
    ) -> SubscribeToPageResponse:
        return self._t.call(_FQN, "SubscribeToPage", request, SubscribeToPageResponse, headers)

    def create_page_subscription(
        self,
        request: CreatePageSubscriptionRequest,
        *,
        headers: dict[str, str] | None = None,
    ) -> CreatePageSubscriptionResponse:
        return self._t.call(
            _FQN, "CreatePageSubscription", request, CreatePageSubscriptionResponse, headers
        )

    def unsubscribe_from_page(
        self,
        request: UnsubscribeFromPageRequest,
        *,
        headers: dict[str, str] | None = None,
    ) -> UnsubscribeFromPageResponse:
        return self._t.call(
            _FQN, "UnsubscribeFromPage", request, UnsubscribeFromPageResponse, headers
        )

    def list_subscribers(
        self,
        request: ListSubscribersRequest,
        *,
        headers: dict[str, str] | None = None,
    ) -> ListSubscribersResponse:
        return self._t.call(_FQN, "ListSubscribers", request, ListSubscribersResponse, headers)

    def get_status_page_content(
        self,
        request: GetStatusPageContentRequest,
        *,
        headers: dict[str, str] | None = None,
    ) -> GetStatusPageContentResponse:
        return self._t.call(
            _FQN, "GetStatusPageContent", request, GetStatusPageContentResponse, headers
        )

    def get_overall_status(
        self,
        request: GetOverallStatusRequest,
        *,
        headers: dict[str, str] | None = None,
    ) -> GetOverallStatusResponse:
        return self._t.call(_FQN, "GetOverallStatus", request, GetOverallStatusResponse, headers)


class AsyncStatusPageServiceClient:
    def __init__(self, transport: _AsyncJsonTransport) -> None:
        self._t = transport

    async def create_status_page(
        self,
        request: CreateStatusPageRequest,
        *,
        headers: dict[str, str] | None = None,
    ) -> CreateStatusPageResponse:
        return await self._t.call(
            _FQN, "CreateStatusPage", request, CreateStatusPageResponse, headers
        )

    async def get_status_page(
        self,
        request: GetStatusPageRequest,
        *,
        headers: dict[str, str] | None = None,
    ) -> GetStatusPageResponse:
        return await self._t.call(_FQN, "GetStatusPage", request, GetStatusPageResponse, headers)

    async def list_status_pages(
        self,
        request: ListStatusPagesRequest,
        *,
        headers: dict[str, str] | None = None,
    ) -> ListStatusPagesResponse:
        return await self._t.call(
            _FQN, "ListStatusPages", request, ListStatusPagesResponse, headers
        )

    async def update_status_page(
        self,
        request: UpdateStatusPageRequest,
        *,
        headers: dict[str, str] | None = None,
    ) -> UpdateStatusPageResponse:
        return await self._t.call(
            _FQN, "UpdateStatusPage", request, UpdateStatusPageResponse, headers
        )

    async def delete_status_page(
        self,
        request: DeleteStatusPageRequest,
        *,
        headers: dict[str, str] | None = None,
    ) -> DeleteStatusPageResponse:
        return await self._t.call(
            _FQN, "DeleteStatusPage", request, DeleteStatusPageResponse, headers
        )

    async def add_monitor_component(
        self,
        request: AddMonitorComponentRequest,
        *,
        headers: dict[str, str] | None = None,
    ) -> AddMonitorComponentResponse:
        return await self._t.call(
            _FQN, "AddMonitorComponent", request, AddMonitorComponentResponse, headers
        )

    async def add_static_component(
        self,
        request: AddStaticComponentRequest,
        *,
        headers: dict[str, str] | None = None,
    ) -> AddStaticComponentResponse:
        return await self._t.call(
            _FQN, "AddStaticComponent", request, AddStaticComponentResponse, headers
        )

    async def remove_component(
        self,
        request: RemoveComponentRequest,
        *,
        headers: dict[str, str] | None = None,
    ) -> RemoveComponentResponse:
        return await self._t.call(
            _FQN, "RemoveComponent", request, RemoveComponentResponse, headers
        )

    async def update_component(
        self,
        request: UpdateComponentRequest,
        *,
        headers: dict[str, str] | None = None,
    ) -> UpdateComponentResponse:
        return await self._t.call(
            _FQN, "UpdateComponent", request, UpdateComponentResponse, headers
        )

    async def create_component_group(
        self,
        request: CreateComponentGroupRequest,
        *,
        headers: dict[str, str] | None = None,
    ) -> CreateComponentGroupResponse:
        return await self._t.call(
            _FQN, "CreateComponentGroup", request, CreateComponentGroupResponse, headers
        )

    async def delete_component_group(
        self,
        request: DeleteComponentGroupRequest,
        *,
        headers: dict[str, str] | None = None,
    ) -> DeleteComponentGroupResponse:
        return await self._t.call(
            _FQN, "DeleteComponentGroup", request, DeleteComponentGroupResponse, headers
        )

    async def update_component_group(
        self,
        request: UpdateComponentGroupRequest,
        *,
        headers: dict[str, str] | None = None,
    ) -> UpdateComponentGroupResponse:
        return await self._t.call(
            _FQN, "UpdateComponentGroup", request, UpdateComponentGroupResponse, headers
        )

    async def subscribe_to_page(
        self,
        request: SubscribeToPageRequest,
        *,
        headers: dict[str, str] | None = None,
    ) -> SubscribeToPageResponse:
        return await self._t.call(
            _FQN, "SubscribeToPage", request, SubscribeToPageResponse, headers
        )

    async def create_page_subscription(
        self,
        request: CreatePageSubscriptionRequest,
        *,
        headers: dict[str, str] | None = None,
    ) -> CreatePageSubscriptionResponse:
        return await self._t.call(
            _FQN, "CreatePageSubscription", request, CreatePageSubscriptionResponse, headers
        )

    async def unsubscribe_from_page(
        self,
        request: UnsubscribeFromPageRequest,
        *,
        headers: dict[str, str] | None = None,
    ) -> UnsubscribeFromPageResponse:
        return await self._t.call(
            _FQN, "UnsubscribeFromPage", request, UnsubscribeFromPageResponse, headers
        )

    async def list_subscribers(
        self,
        request: ListSubscribersRequest,
        *,
        headers: dict[str, str] | None = None,
    ) -> ListSubscribersResponse:
        return await self._t.call(
            _FQN, "ListSubscribers", request, ListSubscribersResponse, headers
        )

    async def get_status_page_content(
        self,
        request: GetStatusPageContentRequest,
        *,
        headers: dict[str, str] | None = None,
    ) -> GetStatusPageContentResponse:
        return await self._t.call(
            _FQN, "GetStatusPageContent", request, GetStatusPageContentResponse, headers
        )

    async def get_overall_status(
        self,
        request: GetOverallStatusRequest,
        *,
        headers: dict[str, str] | None = None,
    ) -> GetOverallStatusResponse:
        return await self._t.call(
            _FQN, "GetOverallStatus", request, GetOverallStatusResponse, headers
        )