async_rest_client.py

# Code generated by GetStream internal OpenAPI code generator. DO NOT EDIT.
from getstream.base import AsyncBaseClient
from getstream.common import telemetry
from getstream.models import *
from getstream.stream_response import StreamResponse
from getstream.utils import build_query_param


class ChatRestClient(AsyncBaseClient):
    def __init__(
        self,
        api_key: str,
        base_url: str,
        timeout: float,
        token: str,
        user_agent: str = None,
    ):
        """
        Initializes ChatClient with BaseClient instance
        :param api_key: A string representing the client's API key
        :param base_url: A string representing the base uniform resource locator
        :param timeout: A number representing the time limit for a request
        :param token: A string instance representing the client's token
        :param user_agent: Optional custom user agent string
        """
        super().__init__(
            api_key=api_key,
            base_url=base_url,
            timeout=timeout,
            token=token,
            user_agent=user_agent,
        )

    @telemetry.operation_name("getstream.api.chat.create_campaign")
    async def create_campaign(
        self,
        sender_id: str,
        message_template: CampaignMessageTemplate,
        create_channels: Optional[bool] = None,
        description: Optional[str] = None,
        id: Optional[str] = None,
        name: Optional[str] = None,
        sender_mode: Optional[str] = None,
        sender_visibility: Optional[str] = None,
        show_channels: Optional[bool] = None,
        skip_push: Optional[bool] = None,
        skip_webhook: Optional[bool] = None,
        segment_ids: Optional[List[str]] = None,
        user_ids: Optional[List[str]] = None,
        channel_template: Optional[CampaignChannelTemplate] = None,
    ) -> StreamResponse[CreateCampaignResponse]:
        json = CreateCampaignRequest(
            sender_id=sender_id,
            message_template=message_template,
            create_channels=create_channels,
            description=description,
            id=id,
            name=name,
            sender_mode=sender_mode,
            sender_visibility=sender_visibility,
            show_channels=show_channels,
            skip_push=skip_push,
            skip_webhook=skip_webhook,
            segment_ids=segment_ids,
            user_ids=user_ids,
            channel_template=channel_template,
        ).to_dict()
        return await self.post(
            "/api/v2/chat/campaigns", CreateCampaignResponse, json=json
        )

    @telemetry.operation_name("getstream.api.chat.query_campaigns")
    async def query_campaigns(
        self,
        limit: Optional[int] = None,
        next: Optional[str] = None,
        prev: Optional[str] = None,
        user_limit: Optional[int] = None,
        sort: Optional[List[SortParamRequest]] = None,
        filter: Optional[Dict[str, object]] = None,
    ) -> StreamResponse[QueryCampaignsResponse]:
        json = QueryCampaignsRequest(
            limit=limit,
            next=next,
            prev=prev,
            user_limit=user_limit,
            sort=sort,
            filter=filter,
        ).to_dict()
        return await self.post(
            "/api/v2/chat/campaigns/query", QueryCampaignsResponse, json=json
        )

    @telemetry.operation_name("getstream.api.chat.delete_campaign")
    async def delete_campaign(self, id: str) -> StreamResponse[DeleteCampaignResponse]:
        path_params = {
            "id": id,
        }
        return await self.delete(
            "/api/v2/chat/campaigns/{id}",
            DeleteCampaignResponse,
            path_params=path_params,
        )

    @telemetry.operation_name("getstream.api.chat.get_campaign")
    async def get_campaign(
        self,
        id: str,
        prev: Optional[str] = None,
        next: Optional[str] = None,
        limit: Optional[int] = None,
    ) -> StreamResponse[GetCampaignResponse]:
        query_params = build_query_param(**{"prev": prev, "next": next, "limit": limit})
        path_params = {
            "id": id,
        }
        return await self.get(
            "/api/v2/chat/campaigns/{id}",
            GetCampaignResponse,
            query_params=query_params,
            path_params=path_params,
        )

    @telemetry.operation_name("getstream.api.chat.update_campaign")
    async def update_campaign(
        self,
        id: str,
        sender_id: str,
        message_template: CampaignMessageTemplate,
        create_channels: Optional[bool] = None,
        description: Optional[str] = None,
        id_: Optional[str] = None,
        name: Optional[str] = None,
        sender_mode: Optional[str] = None,
        sender_visibility: Optional[str] = None,
        show_channels: Optional[bool] = None,
        skip_push: Optional[bool] = None,
        skip_webhook: Optional[bool] = None,
        segment_ids: Optional[List[str]] = None,
        user_ids: Optional[List[str]] = None,
        channel_template: Optional[CampaignChannelTemplate] = None,
    ) -> StreamResponse[CampaignResponse]:
        path_params = {
            "id": id,
        }
        json = UpdateCampaignRequest(
            sender_id=sender_id,
            message_template=message_template,
            create_channels=create_channels,
            description=description,
            id=id_,
            name=name,
            sender_mode=sender_mode,
            sender_visibility=sender_visibility,
            show_channels=show_channels,
            skip_push=skip_push,
            skip_webhook=skip_webhook,
            segment_ids=segment_ids,
            user_ids=user_ids,
            channel_template=channel_template,
        ).to_dict()
        return await self.put(
            "/api/v2/chat/campaigns/{id}",
            CampaignResponse,
            path_params=path_params,
            json=json,
        )

    @telemetry.operation_name("getstream.api.chat.start_campaign")
    async def start_campaign(
        self,
        id: str,
        scheduled_for: Optional[datetime] = None,
        stop_at: Optional[datetime] = None,
    ) -> StreamResponse[StartCampaignResponse]:
        path_params = {
            "id": id,
        }
        json = StartCampaignRequest(
            scheduled_for=scheduled_for, stop_at=stop_at
        ).to_dict()
        return await self.post(
            "/api/v2/chat/campaigns/{id}/start",
            StartCampaignResponse,
            path_params=path_params,
            json=json,
        )

    @telemetry.operation_name("getstream.api.chat.stop_campaign")
    async def stop_campaign(
        self,
        id: str,
    ) -> StreamResponse[CampaignResponse]:
        path_params = {
            "id": id,
        }
        json = StopCampaignRequest().to_dict()
        return await self.post(
            "/api/v2/chat/campaigns/{id}/stop",
            CampaignResponse,
            path_params=path_params,
            json=json,
        )

    @telemetry.operation_name("getstream.api.chat.query_channels")
    async def query_channels(
        self,
        limit: Optional[int] = None,
        member_limit: Optional[int] = None,
        message_limit: Optional[int] = None,
        offset: Optional[int] = None,
        predefined_filter: Optional[str] = None,
        state: Optional[bool] = None,
        user_id: Optional[str] = None,
        sort: Optional[List[SortParamRequest]] = None,
        filter_conditions: Optional[Dict[str, object]] = None,
        filter_values: Optional[Dict[str, object]] = None,
        sort_values: Optional[Dict[str, object]] = None,
        user: Optional[UserRequest] = None,
    ) -> StreamResponse[QueryChannelsResponse]:
        json = QueryChannelsRequest(
            limit=limit,
            member_limit=member_limit,
            message_limit=message_limit,
            offset=offset,
            predefined_filter=predefined_filter,
            state=state,
            user_id=user_id,
            sort=sort,
            filter_conditions=filter_conditions,
            filter_values=filter_values,
            sort_values=sort_values,
            user=user,
        ).to_dict()
        return await self.post(
            "/api/v2/chat/channels", QueryChannelsResponse, json=json
        )

    @telemetry.operation_name("getstream.api.chat.channel_batch_update")
    async def channel_batch_update(
        self,
        operation: str,
        filter: Dict[str, object],
        members: Optional[List[ChannelBatchMemberRequest]] = None,
        data: Optional[ChannelDataUpdate] = None,
    ) -> StreamResponse[ChannelBatchUpdateResponse]:
        json = ChannelBatchUpdateRequest(
            operation=operation, filter=filter, members=members, data=data
        ).to_dict()
        return await self.put(
            "/api/v2/chat/channels/batch", ChannelBatchUpdateResponse, json=json
        )

    @telemetry.operation_name("getstream.api.chat.delete_channels")
    async def delete_channels(
        self, cids: List[str], hard_delete: Optional[bool] = None
    ) -> StreamResponse[DeleteChannelsResponse]:
        json = DeleteChannelsRequest(cids=cids, hard_delete=hard_delete).to_dict()
        return await self.post(
            "/api/v2/chat/channels/delete", DeleteChannelsResponse, json=json
        )

    @telemetry.operation_name("getstream.api.chat.mark_delivered")
    async def mark_delivered(
        self,
        user_id: Optional[str] = None,
        latest_delivered_messages: Optional[List[DeliveredMessagePayload]] = None,
    ) -> StreamResponse[MarkDeliveredResponse]:
        query_params = build_query_param(**{"user_id": user_id})
        json = MarkDeliveredRequest(
            latest_delivered_messages=latest_delivered_messages
        ).to_dict()
        return await self.post(
            "/api/v2/chat/channels/delivered",
            MarkDeliveredResponse,
            query_params=query_params,
            json=json,
        )

    @telemetry.operation_name("getstream.api.chat.grouped_query_channels")
    async def grouped_query_channels(
        self,
        limit: Optional[int] = None,
        user_id: Optional[str] = None,
        user: Optional[UserRequest] = None,
    ) -> StreamResponse[GroupedQueryChannelsResponse]:
        json = GroupedQueryChannelsRequest(
            limit=limit, user_id=user_id, user=user
        ).to_dict()
        return await self.post(
            "/api/v2/chat/channels/grouped", GroupedQueryChannelsResponse, json=json
        )

    @telemetry.operation_name("getstream.api.chat.mark_channels_read")
    async def mark_channels_read(
        self,
        user_id: Optional[str] = None,
        read_by_channel: Optional[Dict[str, str]] = None,
        user: Optional[UserRequest] = None,
    ) -> StreamResponse[MarkReadResponse]:
        json = MarkChannelsReadRequest(
            user_id=user_id, read_by_channel=read_by_channel, user=user
        ).to_dict()
        return await self.post(
            "/api/v2/chat/channels/read", MarkReadResponse, json=json
        )

    @telemetry.operation_name("getstream.api.chat.get_or_create_distinct_channel")
    async def get_or_create_distinct_channel(
        self,
        type: str,
        hide_for_creator: Optional[bool] = None,
        state: Optional[bool] = None,
        thread_unread_counts: Optional[bool] = None,
        data: Optional[ChannelInput] = None,
        members: Optional[PaginationParams] = None,
        messages: Optional[MessagePaginationParams] = None,
        watchers: Optional[PaginationParams] = None,
    ) -> StreamResponse[ChannelStateResponse]:
        path_params = {
            "type": type,
        }
        json = ChannelGetOrCreateRequest(
            hide_for_creator=hide_for_creator,
            state=state,
            thread_unread_counts=thread_unread_counts,
            data=data,
            members=members,
            messages=messages,
            watchers=watchers,
        ).to_dict()
        return await self.post(
            "/api/v2/chat/channels/{type}/query",
            ChannelStateResponse,
            path_params=path_params,
            json=json,
        )

    @telemetry.operation_name("getstream.api.chat.delete_channel")
    async def delete_channel(
        self, type: str, id: str, hard_delete: Optional[bool] = None
    ) -> StreamResponse[DeleteChannelResponse]:
        query_params = build_query_param(**{"hard_delete": hard_delete})
        path_params = {
            "type": type,
            "id": id,
        }
        return await self.delete(
            "/api/v2/chat/channels/{type}/{id}",
            DeleteChannelResponse,
            query_params=query_params,
            path_params=path_params,
        )

    @telemetry.operation_name("getstream.api.chat.update_channel_partial")
    async def update_channel_partial(
        self,
        type: str,
        id: str,
        user_id: Optional[str] = None,
        unset: Optional[List[str]] = None,
        set: Optional[Dict[str, object]] = None,
        user: Optional[UserRequest] = None,
    ) -> StreamResponse[UpdateChannelPartialResponse]:
        path_params = {
            "type": type,
            "id": id,
        }
        json = UpdateChannelPartialRequest(
            user_id=user_id, unset=unset, set=set, user=user
        ).to_dict()
        return await self.patch(
            "/api/v2/chat/channels/{type}/{id}",
            UpdateChannelPartialResponse,
            path_params=path_params,
            json=json,
        )

    @telemetry.operation_name("getstream.api.chat.update_channel")
    async def update_channel(
        self,
        type: str,
        id: str,
        accept_invite: Optional[bool] = None,
        cooldown: Optional[int] = None,
        hide_history: Optional[bool] = None,
        hide_history_before: Optional[datetime] = None,
        reject_invite: Optional[bool] = None,
        skip_push: Optional[bool] = None,
        user_id: Optional[str] = None,
        add_filter_tags: Optional[List[str]] = None,
        add_members: Optional[List[ChannelMemberRequest]] = None,
        add_moderators: Optional[List[str]] = None,
        assign_roles: Optional[List[ChannelMemberRequest]] = None,
        demote_moderators: Optional[List[str]] = None,
        invites: Optional[List[ChannelMemberRequest]] = None,
        remove_filter_tags: Optional[List[str]] = None,
        remove_members: Optional[List[str]] = None,
        data: Optional[ChannelInputRequest] = None,
        message: Optional[MessageRequest] = None,
        user: Optional[UserRequest] = None,
    ) -> StreamResponse[UpdateChannelResponse]:
        path_params = {
            "type": type,
            "id": id,
        }
        json = UpdateChannelRequest(
            accept_invite=accept_invite,
            cooldown=cooldown,
            hide_history=hide_history,
            hide_history_before=hide_history_before,
            reject_invite=reject_invite,
            skip_push=skip_push,
            user_id=user_id,
            add_filter_tags=add_filter_tags,
            add_members=add_members,
            add_moderators=add_moderators,
            assign_roles=assign_roles,
            demote_moderators=demote_moderators,
            invites=invites,
            remove_filter_tags=remove_filter_tags,
            remove_members=remove_members,
            data=data,
            message=message,
            user=user,
        ).to_dict()
        return await self.post(
            "/api/v2/chat/channels/{type}/{id}",
            UpdateChannelResponse,
            path_params=path_params,
            json=json,
        )

    @telemetry.operation_name("getstream.api.chat.delete_draft")
    async def delete_draft(
        self,
        type: str,
        id: str,
        parent_id: Optional[str] = None,
        user_id: Optional[str] = None,
    ) -> StreamResponse[Response]:
        query_params = build_query_param(**{"parent_id": parent_id, "user_id": user_id})
        path_params = {
            "type": type,
            "id": id,
        }
        return await self.delete(
            "/api/v2/chat/channels/{type}/{id}/draft",
            Response,
            query_params=query_params,
            path_params=path_params,
        )

    @telemetry.operation_name("getstream.api.chat.get_draft")
    async def get_draft(
        self,
        type: str,
        id: str,
        parent_id: Optional[str] = None,
        user_id: Optional[str] = None,
    ) -> StreamResponse[GetDraftResponse]:
        query_params = build_query_param(**{"parent_id": parent_id, "user_id": user_id})
        path_params = {
            "type": type,
            "id": id,
        }
        return await self.get(
            "/api/v2/chat/channels/{type}/{id}/draft",
            GetDraftResponse,
            query_params=query_params,
            path_params=path_params,
        )

    @telemetry.operation_name("getstream.api.chat.send_event")
    async def send_event(
        self, type: str, id: str, event: EventRequest
    ) -> StreamResponse[EventResponse]:
        path_params = {
            "type": type,
            "id": id,
        }
        json = SendEventRequest(event=event).to_dict()
        return await self.post(
            "/api/v2/chat/channels/{type}/{id}/event",
            EventResponse,
            path_params=path_params,
            json=json,
        )

    @telemetry.operation_name("getstream.api.chat.delete_channel_file")
    async def delete_channel_file(
        self, type: str, id: str, url: Optional[str] = None
    ) -> StreamResponse[Response]:
        query_params = build_query_param(**{"url": url})
        path_params = {
            "type": type,
            "id": id,
        }
        return await self.delete(
            "/api/v2/chat/channels/{type}/{id}/file",
            Response,
            query_params=query_params,
            path_params=path_params,
        )

    @telemetry.operation_name("getstream.api.chat.upload_channel_file")
    async def upload_channel_file(
        self,
        type: str,
        id: str,
        file: Optional[str] = None,
        user: Optional[OnlyUserID] = None,
    ) -> StreamResponse[UploadChannelFileResponse]:
        path_params = {
            "type": type,
            "id": id,
        }
        json = UploadChannelFileRequest(file=file, user=user).to_dict()
        return await self.post(
            "/api/v2/chat/channels/{type}/{id}/file",
            UploadChannelFileResponse,
            path_params=path_params,
            json=json,
        )

    @telemetry.operation_name("getstream.api.chat.hide_channel")
    async def hide_channel(
        self,
        type: str,
        id: str,
        clear_history: Optional[bool] = None,
        user_id: Optional[str] = None,
        user: Optional[UserRequest] = None,
    ) -> StreamResponse[HideChannelResponse]:
        path_params = {
            "type": type,
            "id": id,
        }
        json = HideChannelRequest(
            clear_history=clear_history, user_id=user_id, user=user
        ).to_dict()
        return await self.post(
            "/api/v2/chat/channels/{type}/{id}/hide",
            HideChannelResponse,
            path_params=path_params,
            json=json,
        )

    @telemetry.operation_name("getstream.api.chat.delete_channel_image")
    async def delete_channel_image(
        self, type: str, id: str, url: Optional[str] = None
    ) -> StreamResponse[Response]:
        query_params = build_query_param(**{"url": url})
        path_params = {
            "type": type,
            "id": id,
        }
        return await self.delete(
            "/api/v2/chat/channels/{type}/{id}/image",
            Response,
            query_params=query_params,
            path_params=path_params,
        )

    @telemetry.operation_name("getstream.api.chat.upload_channel_image")
    async def upload_channel_image(
        self,
        type: str,
        id: str,
        file: Optional[str] = None,
        upload_sizes: Optional[List[ImageSize]] = None,
        user: Optional[OnlyUserID] = None,
    ) -> StreamResponse[UploadChannelResponse]:
        path_params = {
            "type": type,
            "id": id,
        }
        json = UploadChannelRequest(
            file=file, upload_sizes=upload_sizes, user=user
        ).to_dict()
        return await self.post(
            "/api/v2/chat/channels/{type}/{id}/image",
            UploadChannelResponse,
            path_params=path_params,
            json=json,
        )

    @telemetry.operation_name("getstream.api.chat.update_member_partial")
    async def update_member_partial(
        self,
        type: str,
        id: str,
        user_id: Optional[str] = None,
        unset: Optional[List[str]] = None,
        set: Optional[Dict[str, object]] = None,
    ) -> StreamResponse[UpdateMemberPartialResponse]:
        query_params = build_query_param(**{"user_id": user_id})
        path_params = {
            "type": type,
            "id": id,
        }
        json = UpdateMemberPartialRequest(unset=unset, set=set).to_dict()
        return await self.patch(
            "/api/v2/chat/channels/{type}/{id}/member",
            UpdateMemberPartialResponse,
            query_params=query_params,
            path_params=path_params,
            json=json,
        )

    @telemetry.operation_name("getstream.api.chat.send_message")
    async def send_message(
        self,
        type: str,
        id: str,
        message: MessageRequest,
        force_moderation: Optional[bool] = None,
        keep_channel_hidden: Optional[bool] = None,
        pending: Optional[bool] = None,
        skip_enrich_url: Optional[bool] = None,
        skip_push: Optional[bool] = None,
        pending_message_metadata: Optional[Dict[str, str]] = None,
    ) -> StreamResponse[SendMessageResponse]:
        path_params = {
            "type": type,
            "id": id,
        }
        json = SendMessageRequest(
            message=message,
            force_moderation=force_moderation,
            keep_channel_hidden=keep_channel_hidden,
            pending=pending,
            skip_enrich_url=skip_enrich_url,
            skip_push=skip_push,
            pending_message_metadata=pending_message_metadata,
        ).to_dict()
        return await self.post(
            "/api/v2/chat/channels/{type}/{id}/message",
            SendMessageResponse,
            path_params=path_params,
            json=json,
        )

    @telemetry.operation_name("getstream.api.chat.get_many_messages")
    async def get_many_messages(
        self, type: str, id: str, ids: List[str]
    ) -> StreamResponse[GetManyMessagesResponse]:
        query_params = build_query_param(**{"ids": ids})
        path_params = {
            "type": type,
            "id": id,
        }
        return await self.get(
            "/api/v2/chat/channels/{type}/{id}/messages",
            GetManyMessagesResponse,
            query_params=query_params,
            path_params=path_params,
        )

    @telemetry.operation_name("getstream.api.chat.get_or_create_channel")
    async def get_or_create_channel(
        self,
        type: str,
        id: str,
        hide_for_creator: Optional[bool] = None,
        state: Optional[bool] = None,
        thread_unread_counts: Optional[bool] = None,
        data: Optional[ChannelInput] = None,
        members: Optional[PaginationParams] = None,
        messages: Optional[MessagePaginationParams] = None,
        watchers: Optional[PaginationParams] = None,
    ) -> StreamResponse[ChannelStateResponse]:
        path_params = {
            "type": type,
            "id": id,
        }
        json = ChannelGetOrCreateRequest(
            hide_for_creator=hide_for_creator,
            state=state,
            thread_unread_counts=thread_unread_counts,
            data=data,
            members=members,
            messages=messages,
            watchers=watchers,
        ).to_dict()
        return await self.post(
            "/api/v2/chat/channels/{type}/{id}/query",
            ChannelStateResponse,
            path_params=path_params,
            json=json,
        )

    @telemetry.operation_name("getstream.api.chat.mark_read")
    async def mark_read(
        self,
        type: str,
        id: str,
        message_id: Optional[str] = None,
        thread_id: Optional[str] = None,
        user_id: Optional[str] = None,
        user: Optional[UserRequest] = None,
    ) -> StreamResponse[MarkReadResponse]:
        path_params = {
            "type": type,
            "id": id,
        }
        json = MarkReadRequest(
            message_id=message_id, thread_id=thread_id, user_id=user_id, user=user
        ).to_dict()
        return await self.post(
            "/api/v2/chat/channels/{type}/{id}/read",
            MarkReadResponse,
            path_params=path_params,
            json=json,
        )

    @telemetry.operation_name("getstream.api.chat.show_channel")
    async def show_channel(
        self,
        type: str,
        id: str,
        user_id: Optional[str] = None,
        user: Optional[UserRequest] = None,
    ) -> StreamResponse[ShowChannelResponse]:
        path_params = {
            "type": type,
            "id": id,
        }
        json = ShowChannelRequest(user_id=user_id, user=user).to_dict()
        return await self.post(
            "/api/v2/chat/channels/{type}/{id}/show",
            ShowChannelResponse,
            path_params=path_params,
            json=json,
        )

    @telemetry.operation_name("getstream.api.chat.truncate_channel")
    async def truncate_channel(
        self,
        type: str,
        id: str,
        hard_delete: Optional[bool] = None,
        skip_push: Optional[bool] = None,
        truncated_at: Optional[datetime] = None,
        user_id: Optional[str] = None,
        member_ids: Optional[List[str]] = None,
        message: Optional[MessageRequest] = None,
        user: Optional[UserRequest] = None,
    ) -> StreamResponse[TruncateChannelResponse]:
        path_params = {
            "type": type,
            "id": id,
        }
        json = TruncateChannelRequest(
            hard_delete=hard_delete,
            skip_push=skip_push,
            truncated_at=truncated_at,
            user_id=user_id,
            member_ids=member_ids,
            message=message,
            user=user,
        ).to_dict()
        return await self.post(
            "/api/v2/chat/channels/{type}/{id}/truncate",
            TruncateChannelResponse,
            path_params=path_params,
            json=json,
        )

    @telemetry.operation_name("getstream.api.chat.mark_unread")
    async def mark_unread(
        self,
        type: str,
        id: str,
        message_id: Optional[str] = None,
        message_timestamp: Optional[datetime] = None,
        thread_id: Optional[str] = None,
        user_id: Optional[str] = None,
        user: Optional[UserRequest] = None,
    ) -> StreamResponse[Response]:
        path_params = {
            "type": type,
            "id": id,
        }
        json = MarkUnreadRequest(
            message_id=message_id,
            message_timestamp=message_timestamp,
            thread_id=thread_id,
            user_id=user_id,
            user=user,
        ).to_dict()
        return await self.post(
            "/api/v2/chat/channels/{type}/{id}/unread",
            Response,
            path_params=path_params,
            json=json,
        )

    @telemetry.operation_name("getstream.api.chat.list_channel_types")
    async def list_channel_types(self) -> StreamResponse[ListChannelTypesResponse]:
        return await self.get("/api/v2/chat/channeltypes", ListChannelTypesResponse)

    @telemetry.operation_name("getstream.api.chat.create_channel_type")
    async def create_channel_type(
        self,
        automod: str,
        automod_behavior: str,
        max_message_length: int,
        name: str,
        blocklist: Optional[str] = None,
        blocklist_behavior: Optional[str] = None,
        connect_events: Optional[bool] = None,
        count_messages: Optional[bool] = None,
        custom_events: Optional[bool] = None,
        delivery_events: Optional[bool] = None,
        mark_messages_pending: Optional[bool] = None,
        message_retention: Optional[str] = None,
        mutes: Optional[bool] = None,
        partition_size: Optional[int] = None,
        partition_ttl: Optional[str] = None,
        polls: Optional[bool] = None,
        push_level: Optional[str] = None,
        push_notifications: Optional[bool] = None,
        reactions: Optional[bool] = None,
        read_events: Optional[bool] = None,
        replies: Optional[bool] = None,
        search: Optional[bool] = None,
        shared_locations: Optional[bool] = None,
        skip_last_msg_update_for_system_msgs: Optional[bool] = None,
        typing_events: Optional[bool] = None,
        uploads: Optional[bool] = None,
        url_enrichment: Optional[bool] = None,
        user_message_reminders: Optional[bool] = None,
        blocklists: Optional[List[BlockListOptions]] = None,
        commands: Optional[List[str]] = None,
        permissions: Optional[List[PolicyRequest]] = None,
        chat_preferences: Optional[ChatPreferences] = None,
        grants: Optional[Dict[str, List[str]]] = None,
    ) -> StreamResponse[CreateChannelTypeResponse]:
        json = CreateChannelTypeRequest(
            automod=automod,
            automod_behavior=automod_behavior,
            max_message_length=max_message_length,
            name=name,
            blocklist=blocklist,
            blocklist_behavior=blocklist_behavior,
            connect_events=connect_events,
            count_messages=count_messages,
            custom_events=custom_events,
            delivery_events=delivery_events,
            mark_messages_pending=mark_messages_pending,
            message_retention=message_retention,
            mutes=mutes,
            partition_size=partition_size,
            partition_ttl=partition_ttl,
            polls=polls,
            push_level=push_level,
            push_notifications=push_notifications,
            reactions=reactions,
            read_events=read_events,
            replies=replies,
            search=search,
            shared_locations=shared_locations,
            skip_last_msg_update_for_system_msgs=skip_last_msg_update_for_system_msgs,
            typing_events=typing_events,
            uploads=uploads,
            url_enrichment=url_enrichment,
            user_message_reminders=user_message_reminders,
            blocklists=blocklists,
            commands=commands,
            permissions=permissions,
            chat_preferences=chat_preferences,
            grants=grants,
        ).to_dict()
        return await self.post(
            "/api/v2/chat/channeltypes", CreateChannelTypeResponse, json=json
        )

    @telemetry.operation_name("getstream.api.chat.delete_channel_type")
    async def delete_channel_type(self, name: str) -> StreamResponse[Response]:
        path_params = {
            "name": name,
        }
        return await self.delete(
            "/api/v2/chat/channeltypes/{name}", Response, path_params=path_params
        )

    @telemetry.operation_name("getstream.api.chat.get_channel_type")
    async def get_channel_type(
        self, name: str
    ) -> StreamResponse[GetChannelTypeResponse]:
        path_params = {
            "name": name,
        }
        return await self.get(
            "/api/v2/chat/channeltypes/{name}",
            GetChannelTypeResponse,
            path_params=path_params,
        )

    @telemetry.operation_name("getstream.api.chat.update_channel_type")
    async def update_channel_type(
        self,
        name: str,
        automod: str,
        automod_behavior: str,
        max_message_length: int,
        blocklist: Optional[str] = None,
        blocklist_behavior: Optional[str] = None,
        connect_events: Optional[bool] = None,
        count_messages: Optional[bool] = None,
        custom_events: Optional[bool] = None,
        delivery_events: Optional[bool] = None,
        mark_messages_pending: Optional[bool] = None,
        mutes: Optional[bool] = None,
        partition_size: Optional[int] = None,
        partition_ttl: Optional[str] = None,
        polls: Optional[bool] = None,
        push_level: Optional[str] = None,
        push_notifications: Optional[bool] = None,
        quotes: Optional[bool] = None,
        reactions: Optional[bool] = None,
        read_events: Optional[bool] = None,
        reminders: Optional[bool] = None,
        replies: Optional[bool] = None,
        search: Optional[bool] = None,
        shared_locations: Optional[bool] = None,
        skip_last_msg_update_for_system_msgs: Optional[bool] = None,
        typing_events: Optional[bool] = None,
        uploads: Optional[bool] = None,
        url_enrichment: Optional[bool] = None,
        user_message_reminders: Optional[bool] = None,
        allowed_flag_reasons: Optional[List[str]] = None,
        blocklists: Optional[List[BlockListOptions]] = None,
        commands: Optional[List[str]] = None,
        permissions: Optional[List[PolicyRequest]] = None,
        automod_thresholds: Optional[Thresholds] = None,
        chat_preferences: Optional[ChatPreferences] = None,
        grants: Optional[Dict[str, List[str]]] = None,
    ) -> StreamResponse[UpdateChannelTypeResponse]:
        path_params = {
            "name": name,
        }
        json = UpdateChannelTypeRequest(
            automod=automod,
            automod_behavior=automod_behavior,
            max_message_length=max_message_length,
            blocklist=blocklist,
            blocklist_behavior=blocklist_behavior,
            connect_events=connect_events,
            count_messages=count_messages,
            custom_events=custom_events,
            delivery_events=delivery_events,
            mark_messages_pending=mark_messages_pending,
            mutes=mutes,
            partition_size=partition_size,
            partition_ttl=partition_ttl,
            polls=polls,
            push_level=push_level,
            push_notifications=push_notifications,
            quotes=quotes,
            reactions=reactions,
            read_events=read_events,
            reminders=reminders,
            replies=replies,
            search=search,
            shared_locations=shared_locations,
            skip_last_msg_update_for_system_msgs=skip_last_msg_update_for_system_msgs,
            typing_events=typing_events,
            uploads=uploads,
            url_enrichment=url_enrichment,
            user_message_reminders=user_message_reminders,
            allowed_flag_reasons=allowed_flag_reasons,
            blocklists=blocklists,
            commands=commands,
            permissions=permissions,
            automod_thresholds=automod_thresholds,
            chat_preferences=chat_preferences,
            grants=grants,
        ).to_dict()
        return await self.put(
            "/api/v2/chat/channeltypes/{name}",
            UpdateChannelTypeResponse,
            path_params=path_params,
            json=json,
        )

    @telemetry.operation_name("getstream.api.chat.list_commands")
    async def list_commands(self) -> StreamResponse[ListCommandsResponse]:
        return await self.get("/api/v2/chat/commands", ListCommandsResponse)

    @telemetry.operation_name("getstream.api.chat.create_command")
    async def create_command(
        self,
        description: str,
        name: str,
        args: Optional[str] = None,
        set: Optional[str] = None,
    ) -> StreamResponse[CreateCommandResponse]:
        json = CreateCommandRequest(
            description=description, name=name, args=args, set=set
        ).to_dict()
        return await self.post(
            "/api/v2/chat/commands", CreateCommandResponse, json=json
        )

    @telemetry.operation_name("getstream.api.chat.delete_command")
    async def delete_command(self, name: str) -> StreamResponse[DeleteCommandResponse]:
        path_params = {
            "name": name,
        }
        return await self.delete(
            "/api/v2/chat/commands/{name}",
            DeleteCommandResponse,
            path_params=path_params,
        )

    @telemetry.operation_name("getstream.api.chat.get_command")
    async def get_command(self, name: str) -> StreamResponse[GetCommandResponse]:
        path_params = {
            "name": name,
        }
        return await self.get(
            "/api/v2/chat/commands/{name}", GetCommandResponse, path_params=path_params
        )

    @telemetry.operation_name("getstream.api.chat.update_command")
    async def update_command(
        self,
        name: str,
        description: str,
        args: Optional[str] = None,
        set: Optional[str] = None,
    ) -> StreamResponse[UpdateCommandResponse]:
        path_params = {
            "name": name,
        }
        json = UpdateCommandRequest(
            description=description, args=args, set=set
        ).to_dict()
        return await self.put(
            "/api/v2/chat/commands/{name}",
            UpdateCommandResponse,
            path_params=path_params,
            json=json,
        )

    @telemetry.operation_name("getstream.api.chat.query_drafts")
    async def query_drafts(
        self,
        limit: Optional[int] = None,
        next: Optional[str] = None,
        prev: Optional[str] = None,
        user_id: Optional[str] = None,
        sort: Optional[List[SortParamRequest]] = None,
        filter: Optional[Dict[str, object]] = None,
        user: Optional[UserRequest] = None,
    ) -> StreamResponse[QueryDraftsResponse]:
        json = QueryDraftsRequest(
            limit=limit,
            next=next,
            prev=prev,
            user_id=user_id,
            sort=sort,
            filter=filter,
            user=user,
        ).to_dict()
        return await self.post(
            "/api/v2/chat/drafts/query", QueryDraftsResponse, json=json
        )

    @telemetry.operation_name("getstream.api.chat.export_channels")
    async def export_channels(
        self,
        channels: List[ChannelExport],
        clear_deleted_message_text: Optional[bool] = None,
        export_users: Optional[bool] = None,
        include_soft_deleted_channels: Optional[bool] = None,
        include_truncated_messages: Optional[bool] = None,
        version: Optional[str] = None,
    ) -> StreamResponse[ExportChannelsResponse]:
        json = ExportChannelsRequest(
            channels=channels,
            clear_deleted_message_text=clear_deleted_message_text,
            export_users=export_users,
            include_soft_deleted_channels=include_soft_deleted_channels,
            include_truncated_messages=include_truncated_messages,
            version=version,
        ).to_dict()
        return await self.post(
            "/api/v2/chat/export_channels", ExportChannelsResponse, json=json
        )

    @telemetry.operation_name("getstream.api.chat.query_members")
    async def query_members(
        self, payload: Optional[QueryMembersPayload] = None
    ) -> StreamResponse[MembersResponse]:
        query_params = build_query_param(**{"payload": payload})
        return await self.get(
            "/api/v2/chat/members", MembersResponse, query_params=query_params
        )

    @telemetry.operation_name("getstream.api.chat.query_message_history")
    async def query_message_history(
        self,
        filter: Dict[str, object],
        limit: Optional[int] = None,
        next: Optional[str] = None,
        prev: Optional[str] = None,
        sort: Optional[List[SortParamRequest]] = None,
    ) -> StreamResponse[QueryMessageHistoryResponse]:
        json = QueryMessageHistoryRequest(
            filter=filter, limit=limit, next=next, prev=prev, sort=sort
        ).to_dict()
        return await self.post(
            "/api/v2/chat/messages/history", QueryMessageHistoryResponse, json=json
        )

    @telemetry.operation_name("getstream.api.chat.delete_message")
    async def delete_message(
        self,
        id: str,
        hard: Optional[bool] = None,
        deleted_by: Optional[str] = None,
        delete_for_me: Optional[bool] = None,
    ) -> StreamResponse[DeleteMessageResponse]:
        query_params = build_query_param(
            **{"hard": hard, "deleted_by": deleted_by, "delete_for_me": delete_for_me}
        )
        path_params = {
            "id": id,
        }
        return await self.delete(
            "/api/v2/chat/messages/{id}",
            DeleteMessageResponse,
            query_params=query_params,
            path_params=path_params,
        )

    @telemetry.operation_name("getstream.api.chat.get_message")
    async def get_message(
        self, id: str, show_deleted_message: Optional[bool] = None
    ) -> StreamResponse[GetMessageResponse]:
        query_params = build_query_param(
            **{"show_deleted_message": show_deleted_message}
        )
        path_params = {
            "id": id,
        }
        return await self.get(
            "/api/v2/chat/messages/{id}",
            GetMessageResponse,
            query_params=query_params,
            path_params=path_params,
        )

    @telemetry.operation_name("getstream.api.chat.update_message")
    async def update_message(
        self,
        id: str,
        message: MessageRequest,
        skip_enrich_url: Optional[bool] = None,
        skip_push: Optional[bool] = None,
    ) -> StreamResponse[UpdateMessageResponse]:
        path_params = {
            "id": id,
        }
        json = UpdateMessageRequest(
            message=message, skip_enrich_url=skip_enrich_url, skip_push=skip_push
        ).to_dict()
        return await self.post(
            "/api/v2/chat/messages/{id}",
            UpdateMessageResponse,
            path_params=path_params,
            json=json,
        )

    @telemetry.operation_name("getstream.api.chat.update_message_partial")
    async def update_message_partial(
        self,
        id: str,
        skip_enrich_url: Optional[bool] = None,
        skip_push: Optional[bool] = None,
        user_id: Optional[str] = None,
        unset: Optional[List[str]] = None,
        set: Optional[Dict[str, object]] = None,
        user: Optional[UserRequest] = None,
    ) -> StreamResponse[UpdateMessagePartialResponse]:
        path_params = {
            "id": id,
        }
        json = UpdateMessagePartialRequest(
            skip_enrich_url=skip_enrich_url,
            skip_push=skip_push,
            user_id=user_id,
            unset=unset,
            set=set,
            user=user,
        ).to_dict()
        return await self.put(
            "/api/v2/chat/messages/{id}",
            UpdateMessagePartialResponse,
            path_params=path_params,
            json=json,
        )

    @telemetry.operation_name("getstream.api.chat.run_message_action")
    async def run_message_action(
        self,
        id: str,
        form_data: Dict[str, str],
        user_id: Optional[str] = None,
        user: Optional[UserRequest] = None,
    ) -> StreamResponse[MessageActionResponse]:
        path_params = {
            "id": id,
        }
        json = MessageActionRequest(
            form_data=form_data, user_id=user_id, user=user
        ).to_dict()
        return await self.post(
            "/api/v2/chat/messages/{id}/action",
            MessageActionResponse,
            path_params=path_params,
            json=json,
        )

    @telemetry.operation_name("getstream.api.chat.commit_message")
    async def commit_message(
        self,
        id: str,
    ) -> StreamResponse[MessageActionResponse]:
        path_params = {
            "id": id,
        }
        json = CommitMessageRequest().to_dict()
        return await self.post(
            "/api/v2/chat/messages/{id}/commit",
            MessageActionResponse,
            path_params=path_params,
            json=json,
        )

    @telemetry.operation_name("getstream.api.chat.ephemeral_message_update")
    async def ephemeral_message_update(
        self,
        id: str,
        skip_enrich_url: Optional[bool] = None,
        skip_push: Optional[bool] = None,
        user_id: Optional[str] = None,
        unset: Optional[List[str]] = None,
        set: Optional[Dict[str, object]] = None,
        user: Optional[UserRequest] = None,
    ) -> StreamResponse[UpdateMessagePartialResponse]:
        path_params = {
            "id": id,
        }
        json = UpdateMessagePartialRequest(
            skip_enrich_url=skip_enrich_url,
            skip_push=skip_push,
            user_id=user_id,
            unset=unset,
            set=set,
            user=user,
        ).to_dict()
        return await self.patch(
            "/api/v2/chat/messages/{id}/ephemeral",
            UpdateMessagePartialResponse,
            path_params=path_params,
            json=json,
        )

    @telemetry.operation_name("getstream.api.chat.send_reaction")
    async def send_reaction(
        self,
        id: str,
        reaction: ReactionRequest,
        enforce_unique: Optional[bool] = None,
        skip_push: Optional[bool] = None,
    ) -> StreamResponse[SendReactionResponse]:
        path_params = {
            "id": id,
        }
        json = SendReactionRequest(
            reaction=reaction, enforce_unique=enforce_unique, skip_push=skip_push
        ).to_dict()
        return await self.post(
            "/api/v2/chat/messages/{id}/reaction",
            SendReactionResponse,
            path_params=path_params,
            json=json,
        )

    @telemetry.operation_name("getstream.api.chat.delete_reaction")
    async def delete_reaction(
        self, id: str, type: str, user_id: Optional[str] = None
    ) -> StreamResponse[DeleteReactionResponse]:
        query_params = build_query_param(**{"user_id": user_id})
        path_params = {
            "id": id,
            "type": type,
        }
        return await self.delete(
            "/api/v2/chat/messages/{id}/reaction/{type}",
            DeleteReactionResponse,
            query_params=query_params,
            path_params=path_params,
        )

    @telemetry.operation_name("getstream.api.chat.get_reactions")
    async def get_reactions(
        self, id: str, limit: Optional[int] = None, offset: Optional[int] = None
    ) -> StreamResponse[GetReactionsResponse]:
        query_params = build_query_param(**{"limit": limit, "offset": offset})
        path_params = {
            "id": id,
        }
        return await self.get(
            "/api/v2/chat/messages/{id}/reactions",
            GetReactionsResponse,
            query_params=query_params,
            path_params=path_params,
        )

    @telemetry.operation_name("getstream.api.chat.query_reactions")
    async def query_reactions(
        self,
        id: str,
        limit: Optional[int] = None,
        next: Optional[str] = None,
        prev: Optional[str] = None,
        user_id: Optional[str] = None,
        sort: Optional[List[SortParamRequest]] = None,
        filter: Optional[Dict[str, object]] = None,
        user: Optional[UserRequest] = None,
    ) -> StreamResponse[QueryReactionsResponse]:
        path_params = {
            "id": id,
        }
        json = QueryReactionsRequest(
            limit=limit,
            next=next,
            prev=prev,
            user_id=user_id,
            sort=sort,
            filter=filter,
            user=user,
        ).to_dict()
        return await self.post(
            "/api/v2/chat/messages/{id}/reactions",
            QueryReactionsResponse,
            path_params=path_params,
            json=json,
        )

    @telemetry.operation_name("getstream.api.chat.translate_message")
    async def translate_message(
        self, id: str, language: str
    ) -> StreamResponse[MessageActionResponse]:
        path_params = {
            "id": id,
        }
        json = TranslateMessageRequest(language=language).to_dict()
        return await self.post(
            "/api/v2/chat/messages/{id}/translate",
            MessageActionResponse,
            path_params=path_params,
            json=json,
        )

    @telemetry.operation_name("getstream.api.chat.undelete_message")
    async def undelete_message(
        self, id: str, undeleted_by: str
    ) -> StreamResponse[UndeleteMessageResponse]:
        path_params = {
            "id": id,
        }
        json = UndeleteMessageRequest(undeleted_by=undeleted_by).to_dict()
        return await self.post(
            "/api/v2/chat/messages/{id}/undelete",
            UndeleteMessageResponse,
            path_params=path_params,
            json=json,
        )

    @telemetry.operation_name("getstream.api.chat.cast_poll_vote")
    async def cast_poll_vote(
        self,
        message_id: str,
        poll_id: str,
        user_id: Optional[str] = None,
        user: Optional[UserRequest] = None,
        vote: Optional[VoteData] = None,
    ) -> StreamResponse[PollVoteResponse]:
        path_params = {
            "message_id": message_id,
            "poll_id": poll_id,
        }
        json = CastPollVoteRequest(user_id=user_id, user=user, vote=vote).to_dict()
        return await self.post(
            "/api/v2/chat/messages/{message_id}/polls/{poll_id}/vote",
            PollVoteResponse,
            path_params=path_params,
            json=json,
        )

    @telemetry.operation_name("getstream.api.chat.delete_poll_vote")
    async def delete_poll_vote(
        self, message_id: str, poll_id: str, vote_id: str, user_id: Optional[str] = None
    ) -> StreamResponse[PollVoteResponse]:
        query_params = build_query_param(**{"user_id": user_id})
        path_params = {
            "message_id": message_id,
            "poll_id": poll_id,
            "vote_id": vote_id,
        }
        return await self.delete(
            "/api/v2/chat/messages/{message_id}/polls/{poll_id}/vote/{vote_id}",
            PollVoteResponse,
            query_params=query_params,
            path_params=path_params,
        )

    @telemetry.operation_name("getstream.api.chat.delete_reminder")
    async def delete_reminder(
        self, message_id: str, user_id: Optional[str] = None
    ) -> StreamResponse[DeleteReminderResponse]:
        query_params = build_query_param(**{"user_id": user_id})
        path_params = {
            "message_id": message_id,
        }
        return await self.delete(
            "/api/v2/chat/messages/{message_id}/reminders",
            DeleteReminderResponse,
            query_params=query_params,
            path_params=path_params,
        )

    @telemetry.operation_name("getstream.api.chat.update_reminder")
    async def update_reminder(
        self,
        message_id: str,
        remind_at: Optional[datetime] = None,
        user_id: Optional[str] = None,
        user: Optional[UserRequest] = None,
    ) -> StreamResponse[UpdateReminderResponse]:
        path_params = {
            "message_id": message_id,
        }
        json = UpdateReminderRequest(
            remind_at=remind_at, user_id=user_id, user=user
        ).to_dict()
        return await self.patch(
            "/api/v2/chat/messages/{message_id}/reminders",
            UpdateReminderResponse,
            path_params=path_params,
            json=json,
        )

    @telemetry.operation_name("getstream.api.chat.create_reminder")
    async def create_reminder(
        self,
        message_id: str,
        remind_at: Optional[datetime] = None,
        user_id: Optional[str] = None,
        user: Optional[UserRequest] = None,
    ) -> StreamResponse[ReminderResponseData]:
        path_params = {
            "message_id": message_id,
        }
        json = CreateReminderRequest(
            remind_at=remind_at, user_id=user_id, user=user
        ).to_dict()
        return await self.post(
            "/api/v2/chat/messages/{message_id}/reminders",
            ReminderResponseData,
            path_params=path_params,
            json=json,
        )

    @telemetry.operation_name("getstream.api.chat.get_replies")
    async def get_replies(
        self,
        parent_id: str,
        limit: Optional[int] = None,
        id_gte: Optional[str] = None,
        id_gt: Optional[str] = None,
        id_lte: Optional[str] = None,
        id_lt: Optional[str] = None,
        id_around: Optional[str] = None,
        sort: Optional[List[SortParamRequest]] = None,
    ) -> StreamResponse[GetRepliesResponse]:
        query_params = build_query_param(
            **{
                "limit": limit,
                "id_gte": id_gte,
                "id_gt": id_gt,
                "id_lte": id_lte,
                "id_lt": id_lt,
                "id_around": id_around,
                "sort": sort,
            }
        )
        path_params = {
            "parent_id": parent_id,
        }
        return await self.get(
            "/api/v2/chat/messages/{parent_id}/replies",
            GetRepliesResponse,
            query_params=query_params,
            path_params=path_params,
        )

    @telemetry.operation_name("getstream.api.chat.query_message_flags")
    async def query_message_flags(
        self, payload: Optional[QueryMessageFlagsPayload] = None
    ) -> StreamResponse[QueryMessageFlagsResponse]:
        query_params = build_query_param(**{"payload": payload})
        return await self.get(
            "/api/v2/chat/moderation/flags/message",
            QueryMessageFlagsResponse,
            query_params=query_params,
        )

    @telemetry.operation_name("getstream.api.chat.mute_channel")
    async def mute_channel(
        self,
        expiration: Optional[int] = None,
        user_id: Optional[str] = None,
        channel_cids: Optional[List[str]] = None,
        user: Optional[UserRequest] = None,
    ) -> StreamResponse[MuteChannelResponse]:
        json = MuteChannelRequest(
            expiration=expiration, user_id=user_id, channel_cids=channel_cids, user=user
        ).to_dict()
        return await self.post(
            "/api/v2/chat/moderation/mute/channel", MuteChannelResponse, json=json
        )

    @telemetry.operation_name("getstream.api.chat.unmute_channel")
    async def unmute_channel(
        self,
        expiration: Optional[int] = None,
        user_id: Optional[str] = None,
        channel_cids: Optional[List[str]] = None,
        user: Optional[UserRequest] = None,
    ) -> StreamResponse[UnmuteResponse]:
        json = UnmuteChannelRequest(
            expiration=expiration, user_id=user_id, channel_cids=channel_cids, user=user
        ).to_dict()
        return await self.post(
            "/api/v2/chat/moderation/unmute/channel", UnmuteResponse, json=json
        )

    @telemetry.operation_name("getstream.api.chat.query_banned_users")
    async def query_banned_users(
        self, payload: Optional[QueryBannedUsersPayload] = None
    ) -> StreamResponse[QueryBannedUsersResponse]:
        query_params = build_query_param(**{"payload": payload})
        return await self.get(
            "/api/v2/chat/query_banned_users",
            QueryBannedUsersResponse,
            query_params=query_params,
        )

    @telemetry.operation_name("getstream.api.chat.query_future_channel_bans")
    async def query_future_channel_bans(
        self, payload: Optional[QueryFutureChannelBansPayload] = None
    ) -> StreamResponse[QueryFutureChannelBansResponse]:
        query_params = build_query_param(**{"payload": payload})
        return await self.get(
            "/api/v2/chat/query_future_channel_bans",
            QueryFutureChannelBansResponse,
            query_params=query_params,
        )

    @telemetry.operation_name("getstream.api.chat.query_reminders")
    async def query_reminders(
        self,
        limit: Optional[int] = None,
        next: Optional[str] = None,
        prev: Optional[str] = None,
        user_id: Optional[str] = None,
        sort: Optional[List[SortParamRequest]] = None,
        filter: Optional[Dict[str, object]] = None,
        user: Optional[UserRequest] = None,
    ) -> StreamResponse[QueryRemindersResponse]:
        json = QueryRemindersRequest(
            limit=limit,
            next=next,
            prev=prev,
            user_id=user_id,
            sort=sort,
            filter=filter,
            user=user,
        ).to_dict()
        return await self.post(
            "/api/v2/chat/reminders/query", QueryRemindersResponse, json=json
        )

    @telemetry.operation_name("getstream.api.chat.get_retention_policy")
    async def get_retention_policy(self) -> StreamResponse[GetRetentionPolicyResponse]:
        return await self.get(
            "/api/v2/chat/retention_policy", GetRetentionPolicyResponse
        )

    @telemetry.operation_name("getstream.api.chat.set_retention_policy")
    async def set_retention_policy(
        self, max_age_hours: int, policy: str
    ) -> StreamResponse[SetRetentionPolicyResponse]:
        json = SetRetentionPolicyRequest(
            max_age_hours=max_age_hours, policy=policy
        ).to_dict()
        return await self.post(
            "/api/v2/chat/retention_policy", SetRetentionPolicyResponse, json=json
        )

    @telemetry.operation_name("getstream.api.chat.delete_retention_policy")
    async def delete_retention_policy(
        self, policy: str
    ) -> StreamResponse[DeleteRetentionPolicyResponse]:
        json = DeleteRetentionPolicyRequest(policy=policy).to_dict()
        return await self.post(
            "/api/v2/chat/retention_policy/delete",
            DeleteRetentionPolicyResponse,
            json=json,
        )

    @telemetry.operation_name("getstream.api.chat.get_retention_policy_runs")
    async def get_retention_policy_runs(
        self,
        limit: Optional[int] = None,
        next: Optional[str] = None,
        prev: Optional[str] = None,
        sort: Optional[List[SortParamRequest]] = None,
        filter_conditions: Optional[Dict[str, object]] = None,
    ) -> StreamResponse[GetRetentionPolicyRunsResponse]:
        json = GetRetentionPolicyRunsRequest(
            limit=limit,
            next=next,
            prev=prev,
            sort=sort,
            filter_conditions=filter_conditions,
        ).to_dict()
        return await self.post(
            "/api/v2/chat/retention_policy/runs",
            GetRetentionPolicyRunsResponse,
            json=json,
        )

    @telemetry.operation_name("getstream.api.chat.search")
    async def search(
        self, payload: Optional[SearchPayload] = None
    ) -> StreamResponse[SearchResponse]:
        query_params = build_query_param(**{"payload": payload})
        return await self.get(
            "/api/v2/chat/search", SearchResponse, query_params=query_params
        )

    @telemetry.operation_name("getstream.api.chat.query_segments")
    async def query_segments(
        self,
        filter: Dict[str, object],
        limit: Optional[int] = None,
        next: Optional[str] = None,
        prev: Optional[str] = None,
        sort: Optional[List[SortParamRequest]] = None,
    ) -> StreamResponse[QuerySegmentsResponse]:
        json = QuerySegmentsRequest(
            filter=filter, limit=limit, next=next, prev=prev, sort=sort
        ).to_dict()
        return await self.post(
            "/api/v2/chat/segments/query", QuerySegmentsResponse, json=json
        )

    @telemetry.operation_name("getstream.api.chat.delete_segment")
    async def delete_segment(self, id: str) -> StreamResponse[Response]:
        path_params = {
            "id": id,
        }
        return await self.delete(
            "/api/v2/chat/segments/{id}", Response, path_params=path_params
        )

    @telemetry.operation_name("getstream.api.chat.get_segment")
    async def get_segment(self, id: str) -> StreamResponse[GetSegmentResponse]:
        path_params = {
            "id": id,
        }
        return await self.get(
            "/api/v2/chat/segments/{id}", GetSegmentResponse, path_params=path_params
        )

    @telemetry.operation_name("getstream.api.chat.delete_segment_targets")
    async def delete_segment_targets(
        self, id: str, target_ids: List[str]
    ) -> StreamResponse[Response]:
        path_params = {
            "id": id,
        }
        json = DeleteSegmentTargetsRequest(target_ids=target_ids).to_dict()
        return await self.post(
            "/api/v2/chat/segments/{id}/deletetargets",
            Response,
            path_params=path_params,
            json=json,
        )

    @telemetry.operation_name("getstream.api.chat.segment_target_exists")
    async def segment_target_exists(
        self, id: str, target_id: str
    ) -> StreamResponse[Response]:
        path_params = {
            "id": id,
            "target_id": target_id,
        }
        return await self.get(
            "/api/v2/chat/segments/{id}/target/{target_id}",
            Response,
            path_params=path_params,
        )

    @telemetry.operation_name("getstream.api.chat.query_segment_targets")
    async def query_segment_targets(
        self,
        id: str,
        limit: Optional[int] = None,
        next: Optional[str] = None,
        prev: Optional[str] = None,
        sort: Optional[List[SortParamRequest]] = None,
        filter: Optional[Dict[str, object]] = None,
    ) -> StreamResponse[QuerySegmentTargetsResponse]:
        path_params = {
            "id": id,
        }
        json = QuerySegmentTargetsRequest(
            limit=limit, next=next, prev=prev, sort=sort, filter=filter
        ).to_dict()
        return await self.post(
            "/api/v2/chat/segments/{id}/targets/query",
            QuerySegmentTargetsResponse,
            path_params=path_params,
            json=json,
        )

    @telemetry.operation_name("getstream.api.chat.query_team_usage_stats")
    async def query_team_usage_stats(
        self,
        end_date: Optional[str] = None,
        limit: Optional[int] = None,
        month: Optional[str] = None,
        next: Optional[str] = None,
        start_date: Optional[str] = None,
    ) -> StreamResponse[QueryTeamUsageStatsResponse]:
        json = QueryTeamUsageStatsRequest(
            end_date=end_date,
            limit=limit,
            month=month,
            next=next,
            start_date=start_date,
        ).to_dict()
        return await self.post(
            "/api/v2/chat/stats/team_usage", QueryTeamUsageStatsResponse, json=json
        )

    @telemetry.operation_name("getstream.api.chat.query_threads")
    async def query_threads(
        self,
        limit: Optional[int] = None,
        member_limit: Optional[int] = None,
        next: Optional[str] = None,
        participant_limit: Optional[int] = None,
        prev: Optional[str] = None,
        reply_limit: Optional[int] = None,
        user_id: Optional[str] = None,
        sort: Optional[List[SortParamRequest]] = None,
        filter: Optional[Dict[str, object]] = None,
        user: Optional[UserRequest] = None,
    ) -> StreamResponse[QueryThreadsResponse]:
        json = QueryThreadsRequest(
            limit=limit,
            member_limit=member_limit,
            next=next,
            participant_limit=participant_limit,
            prev=prev,
            reply_limit=reply_limit,
            user_id=user_id,
            sort=sort,
            filter=filter,
            user=user,
        ).to_dict()
        return await self.post("/api/v2/chat/threads", QueryThreadsResponse, json=json)

    @telemetry.operation_name("getstream.api.chat.get_thread")
    async def get_thread(
        self,
        message_id: str,
        reply_limit: Optional[int] = None,
        participant_limit: Optional[int] = None,
        member_limit: Optional[int] = None,
    ) -> StreamResponse[GetThreadResponse]:
        query_params = build_query_param(
            **{
                "reply_limit": reply_limit,
                "participant_limit": participant_limit,
                "member_limit": member_limit,
            }
        )
        path_params = {
            "message_id": message_id,
        }
        return await self.get(
            "/api/v2/chat/threads/{message_id}",
            GetThreadResponse,
            query_params=query_params,
            path_params=path_params,
        )

    @telemetry.operation_name("getstream.api.chat.update_thread_partial")
    async def update_thread_partial(
        self,
        message_id: str,
        user_id: Optional[str] = None,
        unset: Optional[List[str]] = None,
        set: Optional[Dict[str, object]] = None,
        user: Optional[UserRequest] = None,
    ) -> StreamResponse[UpdateThreadPartialResponse]:
        path_params = {
            "message_id": message_id,
        }
        json = UpdateThreadPartialRequest(
            user_id=user_id, unset=unset, set=set, user=user
        ).to_dict()
        return await self.patch(
            "/api/v2/chat/threads/{message_id}",
            UpdateThreadPartialResponse,
            path_params=path_params,
            json=json,
        )

    @telemetry.operation_name("getstream.api.chat.unread_counts")
    async def unread_counts(
        self, user_id: Optional[str] = None
    ) -> StreamResponse[WrappedUnreadCountsResponse]:
        query_params = build_query_param(**{"user_id": user_id})
        return await self.get(
            "/api/v2/chat/unread",
            WrappedUnreadCountsResponse,
            query_params=query_params,
        )

    @telemetry.operation_name("getstream.api.chat.unread_counts_batch")
    async def unread_counts_batch(
        self, user_ids: List[str]
    ) -> StreamResponse[UnreadCountsBatchResponse]:
        json = UnreadCountsBatchRequest(user_ids=user_ids).to_dict()
        return await self.post(
            "/api/v2/chat/unread_batch", UnreadCountsBatchResponse, json=json
        )

    @telemetry.operation_name("getstream.api.chat.send_user_custom_event")
    async def send_user_custom_event(
        self, user_id: str, event: UserCustomEventRequest
    ) -> StreamResponse[Response]:
        path_params = {
            "user_id": user_id,
        }
        json = SendUserCustomEventRequest(event=event).to_dict()
        return await self.post(
            "/api/v2/chat/users/{user_id}/event",
            Response,
            path_params=path_params,
            json=json,
        )