feat(api): manual updates

Author: stainless-app[bot]

.stats.yml

@@ -1,4 +1,4 @@
 configured_endpoints: 23
-openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/beeper%2Fbeeper-desktop-api-ee25e67fc85ccc86cedb2ca0865385709877582132103e0afa68d7b43551784a.yml
-openapi_spec_hash: d41fd99c9a8645a1fd69c519cd25a637
-config_hash: 07a9227b2e53d5bf022c964ac30d72fa
+openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/beeper%2Fbeeper-desktop-api-1b8324f05cd39e88cfc36b9b86a868b6f7e0c9e0827bb30d70a6d875c151ae52.yml
+openapi_spec_hash: 41410e315f6a3d0be787ece9e4fcb96a
+config_hash: abdcaeff62a619bdf25d727cdeacf3b0

README.md

@@ -23,10 +23,13 @@ The REST API documentation can be found on [developers.beeper.com](https://devel
 ## Installation
 
 ```sh
-# install from PyPI
-pip install beeper_desktop_api
+# install from the production repo
+pip install git+ssh://git@github.com/beeper/desktop-api-python.git
 ```
 
+> [!NOTE]
+> Once this package is [published to PyPI](https://www.stainless.com/docs/guides/publish), this will become: `pip install beeper_desktop_api`
+
 ## Usage
 
 The full API of this library can be found in [api.md](api.md).
@@ -87,8 +90,8 @@ By default, the async client uses `httpx` for HTTP requests. However, for improv
 You can enable this by installing `aiohttp`:
 
 ```sh
-# install from PyPI
-pip install beeper_desktop_api[aiohttp]
+# install from the production repo
+pip install 'beeper_desktop_api[aiohttp] @ git+ssh://git@github.com/beeper/desktop-api-python.git'
 ```
 
 Then you can enable it by instantiating the client with `http_client=DefaultAioHttpClient()`:
@@ -215,10 +218,10 @@ from beeper_desktop_api import BeeperDesktop
 
 client = BeeperDesktop()
 
-client.chats.reminders.create(
-    chat_id="!NCdzlIaMjZUmvmvyHU:beeper.com",
-    reminder={"remind_at_ms": 0},
+chat = client.chats.create(
+    chat={"account_id": "accountID"},
 )
+print(chat.user)
 ```
 
 ## File uploads

src/beeper_desktop_api/resources/chats/chats.py

@@ -79,7 +79,7 @@ def with_streaming_response(self) -> ChatsResourceWithStreamingResponse:
     def create(
         self,
         *,
-        chat: chat_create_params.Chat | Omit = omit,
+        chat: chat_create_params.Chat,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
@@ -383,7 +383,7 @@ def with_streaming_response(self) -> AsyncChatsResourceWithStreamingResponse:
     async def create(
         self,
         *,
-        chat: chat_create_params.Chat | Omit = omit,
+        chat: chat_create_params.Chat,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,

src/beeper_desktop_api/types/chat_create_params.py

@@ -2,44 +2,23 @@
 
 from __future__ import annotations
 
-from typing import Union
-from typing_extensions import Literal, Required, Annotated, TypeAlias, TypedDict
+from typing_extensions import Literal, Required, Annotated, TypedDict
 
 from .._types import SequenceNotStr
 from .._utils import PropertyInfo
 
-__all__ = ["ChatCreateParams", "Chat", "ChatUnionMember0", "ChatUnionMember1", "ChatUnionMember1User"]
+__all__ = ["ChatCreateParams", "Chat", "ChatUser"]
 
 
 class ChatCreateParams(TypedDict, total=False):
-    chat: Chat
+    chat: Required[Chat]
 
 
-class ChatUnionMember0(TypedDict, total=False):
-    account_id: Required[Annotated[str, PropertyInfo(alias="accountID")]]
-    """Account to create the chat on."""
-
-    participant_ids: Required[Annotated[SequenceNotStr[str], PropertyInfo(alias="participantIDs")]]
-    """User IDs to include in the new chat."""
+class ChatUser(TypedDict, total=False):
+    """Required when mode='start'.
 
-    type: Required[Literal["single", "group"]]
+    Merged user-like contact payload used to resolve the best identifier.
     """
-    Chat type to create: 'single' requires exactly one participantID; 'group'
-    supports multiple participants and optional title.
-    """
-
-    message_text: Annotated[str, PropertyInfo(alias="messageText")]
-    """Optional first message content if the platform requires it to create the chat."""
-
-    mode: Literal["create"]
-    """Create mode. Defaults to 'create' when omitted."""
-
-    title: str
-    """Optional title for group chats; ignored for single chats on most platforms."""
-
-
-class ChatUnionMember1User(TypedDict, total=False):
-    """Merged user-like contact payload used to resolve the best identifier."""
 
     id: str
     """Known user ID when available."""
@@ -57,21 +36,40 @@ class ChatUnionMember1User(TypedDict, total=False):
     """Username/handle candidate."""
 
 
-class ChatUnionMember1(TypedDict, total=False):
+class Chat(TypedDict, total=False):
     account_id: Required[Annotated[str, PropertyInfo(alias="accountID")]]
-    """Account to start the chat on."""
-
-    mode: Required[Literal["start"]]
-    """Start mode for resolving/creating a direct chat from merged contact data."""
-
-    user: Required[ChatUnionMember1User]
-    """Merged user-like contact payload used to resolve the best identifier."""
+    """Account to create or start the chat on."""
 
     allow_invite: Annotated[bool, PropertyInfo(alias="allowInvite")]
-    """Whether invite-based DM creation is allowed when required by the platform."""
+    """Whether invite-based DM creation is allowed when required by the platform.
+
+    Used for mode='start'.
+    """
 
     message_text: Annotated[str, PropertyInfo(alias="messageText")]
     """Optional first message content if the platform requires it to create the chat."""
 
+    mode: Literal["create", "start"]
+    """Operation mode. Defaults to 'create' when omitted."""
+
+    participant_ids: Annotated[SequenceNotStr[str], PropertyInfo(alias="participantIDs")]
+    """Required when mode='create'. User IDs to include in the new chat."""
+
+    title: str
+    """
+    Optional title for group chats when mode='create'; ignored for single chats on
+    most platforms.
+    """
+
+    type: Literal["single", "group"]
+    """Required when mode='create'.
+
+    'single' requires exactly one participantID; 'group' supports multiple
+    participants and optional title.
+    """
+
+    user: ChatUser
+    """Required when mode='start'.
 
-Chat: TypeAlias = Union[ChatUnionMember0, ChatUnionMember1]
+    Merged user-like contact payload used to resolve the best identifier.
+    """

tests/api_resources/test_chats.py

@@ -25,26 +25,38 @@ class TestChats:
 
     @parametrize
     def test_method_create(self, client: BeeperDesktop) -> None:
-        chat = client.chats.create()
+        chat = client.chats.create(
+            chat={"account_id": "accountID"},
+        )
         assert_matches_type(ChatCreateResponse, chat, path=["response"])
 
     @parametrize
     def test_method_create_with_all_params(self, client: BeeperDesktop) -> None:
         chat = client.chats.create(
             chat={
                 "account_id": "accountID",
-                "participant_ids": ["string"],
-                "type": "single",
+                "allow_invite": True,
                 "message_text": "messageText",
                 "mode": "create",
+                "participant_ids": ["string"],
                 "title": "title",
+                "type": "single",
+                "user": {
+                    "id": "id",
+                    "email": "email",
+                    "full_name": "fullName",
+                    "phone_number": "phoneNumber",
+                    "username": "username",
+                },
             },
         )
         assert_matches_type(ChatCreateResponse, chat, path=["response"])
 
     @parametrize
     def test_raw_response_create(self, client: BeeperDesktop) -> None:
-        response = client.chats.with_raw_response.create()
+        response = client.chats.with_raw_response.create(
+            chat={"account_id": "accountID"},
+        )
 
         assert response.is_closed is True
         assert response.http_request.headers.get("X-Stainless-Lang") == "python"
@@ -53,7 +65,9 @@ def test_raw_response_create(self, client: BeeperDesktop) -> None:
 
     @parametrize
     def test_streaming_response_create(self, client: BeeperDesktop) -> None:
-        with client.chats.with_streaming_response.create() as response:
+        with client.chats.with_streaming_response.create(
+            chat={"account_id": "accountID"},
+        ) as response:
             assert not response.is_closed
             assert response.http_request.headers.get("X-Stainless-Lang") == "python"
 
@@ -245,26 +259,38 @@ class TestAsyncChats:
 
     @parametrize
     async def test_method_create(self, async_client: AsyncBeeperDesktop) -> None:
-        chat = await async_client.chats.create()
+        chat = await async_client.chats.create(
+            chat={"account_id": "accountID"},
+        )
         assert_matches_type(ChatCreateResponse, chat, path=["response"])
 
     @parametrize
     async def test_method_create_with_all_params(self, async_client: AsyncBeeperDesktop) -> None:
         chat = await async_client.chats.create(
             chat={
                 "account_id": "accountID",
-                "participant_ids": ["string"],
-                "type": "single",
+                "allow_invite": True,
                 "message_text": "messageText",
                 "mode": "create",
+                "participant_ids": ["string"],
                 "title": "title",
+                "type": "single",
+                "user": {
+                    "id": "id",
+                    "email": "email",
+                    "full_name": "fullName",
+                    "phone_number": "phoneNumber",
+                    "username": "username",
+                },
             },
         )
         assert_matches_type(ChatCreateResponse, chat, path=["response"])
 
     @parametrize
     async def test_raw_response_create(self, async_client: AsyncBeeperDesktop) -> None:
-        response = await async_client.chats.with_raw_response.create()
+        response = await async_client.chats.with_raw_response.create(
+            chat={"account_id": "accountID"},
+        )
 
         assert response.is_closed is True
         assert response.http_request.headers.get("X-Stainless-Lang") == "python"
@@ -273,7 +299,9 @@ async def test_raw_response_create(self, async_client: AsyncBeeperDesktop) -> No
 
     @parametrize
     async def test_streaming_response_create(self, async_client: AsyncBeeperDesktop) -> None:
-        async with async_client.chats.with_streaming_response.create() as response:
+        async with async_client.chats.with_streaming_response.create(
+            chat={"account_id": "accountID"},
+        ) as response:
             assert not response.is_closed
             assert response.http_request.headers.get("X-Stainless-Lang") == "python"