diff --git a/.stats.yml b/.stats.yml index 5aab750e..829a0228 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1 +1 @@ -configured_endpoints: 233 +configured_endpoints: 239 diff --git a/api.md b/api.md index 091dc53e..92ef3282 100644 --- a/api.md +++ b/api.md @@ -79,7 +79,6 @@ Types: ```python from mobilerun_sdk.types.credentials.packages import ( CredentialCreateResponse, - CredentialRetrieveResponse, CredentialDeleteResponse, ) ``` @@ -87,7 +86,6 @@ from mobilerun_sdk.types.credentials.packages import ( Methods: - client.credentials.packages.credentials.create(package_name, \*\*params) -> CredentialCreateResponse -- client.credentials.packages.credentials.retrieve(credential_name, \*, package_name) -> CredentialRetrieveResponse - client.credentials.packages.credentials.delete(credential_name, \*, package_name) -> CredentialDeleteResponse #### Fields @@ -108,6 +106,62 @@ Methods: - client.credentials.packages.credentials.fields.update(field_type, \*, package_name, credential_name, \*\*params) -> FieldUpdateResponse - client.credentials.packages.credentials.fields.delete(field_type, \*, package_name, credential_name) -> FieldDeleteResponse +### Links + +Types: + +```python +from mobilerun_sdk.types.credentials.packages import LinkCreateResponse +``` + +Methods: + +- client.credentials.packages.links.create(package_name, \*\*params) -> LinkCreateResponse + +## Onepassword + +Types: + +```python +from mobilerun_sdk.types.credentials import ( + OnepasswordRetrieveResponse, + OnepasswordConnectResponse, + OnepasswordDisconnectResponse, +) +``` + +Methods: + +- client.credentials.onepassword.retrieve() -> OnepasswordRetrieveResponse +- client.credentials.onepassword.connect(\*\*params) -> OnepasswordConnectResponse +- client.credentials.onepassword.disconnect() -> OnepasswordDisconnectResponse + +### Vaults + +#### Items + +Types: + +```python +from mobilerun_sdk.types.credentials.onepassword.vaults import ItemListResponse +``` + +Methods: + +- client.credentials.onepassword.vaults.items.list(vault_id) -> ItemListResponse + +##### Fields + +Types: + +```python +from mobilerun_sdk.types.credentials.onepassword.vaults.items import FieldListResponse +``` + +Methods: + +- client.credentials.onepassword.vaults.items.fields.list(item_id, \*, vault_id) -> FieldListResponse + # Devices Types: @@ -485,6 +539,7 @@ from mobilerun_sdk.types.connect import ( ProxyUpdateResponse, ProxyListResponse, ProxyBuyResponse, + ProxyCheckoutResponse, ProxyEnsureHealthyResponse, ProxyListConnectionsResponse, ProxyPingResponse, @@ -498,6 +553,7 @@ Methods: - client.connect.proxies.list(\*\*params) -> ProxyListResponse - client.connect.proxies.buy(\*\*params) -> ProxyBuyResponse - client.connect.proxies.cancel(id) -> None +- client.connect.proxies.checkout(id) -> ProxyCheckoutResponse - client.connect.proxies.ensure_healthy(id) -> ProxyEnsureHealthyResponse - client.connect.proxies.list_connections(id, \*\*params) -> ProxyListConnectionsResponse - client.connect.proxies.ping(id) -> ProxyPingResponse @@ -881,7 +937,7 @@ from mobilerun_sdk.types.mailboxes import MessageRetrieveResponse, MessageListRe Methods: -- client.mailboxes.messages.retrieve(message_id, \*, mailbox_id) -> MessageRetrieveResponse +- client.mailboxes.messages.retrieve(message_id, \*, mailbox_id, \*\*params) -> MessageRetrieveResponse - client.mailboxes.messages.list(mailbox_id, \*\*params) -> MessageListResponse # Files diff --git a/src/mobilerun_sdk/resources/assistant/conversations.py b/src/mobilerun_sdk/resources/assistant/conversations.py index ef5c5e6b..00677bf0 100644 --- a/src/mobilerun_sdk/resources/assistant/conversations.py +++ b/src/mobilerun_sdk/resources/assistant/conversations.py @@ -467,6 +467,7 @@ def send( message: str, session_id: str, agent: str | Omit = omit, + model: str | Omit = omit, # 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, @@ -504,6 +505,7 @@ def send( "message": message, "session_id": session_id, "agent": agent, + "model": model, }, conversation_send_params.ConversationSendParams, ), @@ -983,6 +985,7 @@ async def send( message: str, session_id: str, agent: str | Omit = omit, + model: str | Omit = omit, # 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, @@ -1020,6 +1023,7 @@ async def send( "message": message, "session_id": session_id, "agent": agent, + "model": model, }, conversation_send_params.ConversationSendParams, ), diff --git a/src/mobilerun_sdk/resources/connect/proxies.py b/src/mobilerun_sdk/resources/connect/proxies.py index 55b8946a..ac2f3589 100644 --- a/src/mobilerun_sdk/resources/connect/proxies.py +++ b/src/mobilerun_sdk/resources/connect/proxies.py @@ -24,6 +24,7 @@ from ...types.connect.proxy_list_response import ProxyListResponse from ...types.connect.proxy_ping_response import ProxyPingResponse from ...types.connect.proxy_update_response import ProxyUpdateResponse +from ...types.connect.proxy_checkout_response import ProxyCheckoutResponse from ...types.connect.proxy_retrieve_response import ProxyRetrieveResponse from ...types.connect.proxy_ensure_healthy_response import ProxyEnsureHealthyResponse from ...types.connect.proxy_list_connections_response import ProxyListConnectionsResponse @@ -282,6 +283,48 @@ def cancel( cast_to=NoneType, ) + def checkout( + self, + id: str, + *, + # 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, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + idempotency_key: str | None = None, + ) -> ProxyCheckoutResponse: + """ + Refreshes a pending dedicated proxy's checkout on explicit payment intent. + Already-paid proxies (provisioning, active, or cancelling) return their current + status without a payment URL. An expired checkout requires a new purchase. + + Args: + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + + idempotency_key: Specify a custom idempotency key for this request + """ + if not id: + raise ValueError(f"Expected a non-empty value for `id` but received {id!r}") + return self._post( + path_template("/connect/proxies/{id}/checkout", id=id), + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + idempotency_key=idempotency_key, + ), + cast_to=ProxyCheckoutResponse, + ) + def ensure_healthy( self, id: str, @@ -763,6 +806,48 @@ async def cancel( cast_to=NoneType, ) + async def checkout( + self, + id: str, + *, + # 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, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + idempotency_key: str | None = None, + ) -> ProxyCheckoutResponse: + """ + Refreshes a pending dedicated proxy's checkout on explicit payment intent. + Already-paid proxies (provisioning, active, or cancelling) return their current + status without a payment URL. An expired checkout requires a new purchase. + + Args: + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + + idempotency_key: Specify a custom idempotency key for this request + """ + if not id: + raise ValueError(f"Expected a non-empty value for `id` but received {id!r}") + return await self._post( + path_template("/connect/proxies/{id}/checkout", id=id), + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + idempotency_key=idempotency_key, + ), + cast_to=ProxyCheckoutResponse, + ) + async def ensure_healthy( self, id: str, @@ -1012,6 +1097,9 @@ def __init__(self, proxies: ProxiesResource) -> None: self.cancel = to_raw_response_wrapper( proxies.cancel, ) + self.checkout = to_raw_response_wrapper( + proxies.checkout, + ) self.ensure_healthy = to_raw_response_wrapper( proxies.ensure_healthy, ) @@ -1042,6 +1130,9 @@ def __init__(self, proxies: AsyncProxiesResource) -> None: self.cancel = async_to_raw_response_wrapper( proxies.cancel, ) + self.checkout = async_to_raw_response_wrapper( + proxies.checkout, + ) self.ensure_healthy = async_to_raw_response_wrapper( proxies.ensure_healthy, ) @@ -1072,6 +1163,9 @@ def __init__(self, proxies: ProxiesResource) -> None: self.cancel = to_streamed_response_wrapper( proxies.cancel, ) + self.checkout = to_streamed_response_wrapper( + proxies.checkout, + ) self.ensure_healthy = to_streamed_response_wrapper( proxies.ensure_healthy, ) @@ -1102,6 +1196,9 @@ def __init__(self, proxies: AsyncProxiesResource) -> None: self.cancel = async_to_streamed_response_wrapper( proxies.cancel, ) + self.checkout = async_to_streamed_response_wrapper( + proxies.checkout, + ) self.ensure_healthy = async_to_streamed_response_wrapper( proxies.ensure_healthy, ) diff --git a/src/mobilerun_sdk/resources/credentials/__init__.py b/src/mobilerun_sdk/resources/credentials/__init__.py index 2ab79030..aeeb0075 100644 --- a/src/mobilerun_sdk/resources/credentials/__init__.py +++ b/src/mobilerun_sdk/resources/credentials/__init__.py @@ -16,6 +16,14 @@ CredentialsResourceWithStreamingResponse, AsyncCredentialsResourceWithStreamingResponse, ) +from .onepassword import ( + OnepasswordResource, + AsyncOnepasswordResource, + OnepasswordResourceWithRawResponse, + AsyncOnepasswordResourceWithRawResponse, + OnepasswordResourceWithStreamingResponse, + AsyncOnepasswordResourceWithStreamingResponse, +) __all__ = [ "PackagesResource", @@ -24,6 +32,12 @@ "AsyncPackagesResourceWithRawResponse", "PackagesResourceWithStreamingResponse", "AsyncPackagesResourceWithStreamingResponse", + "OnepasswordResource", + "AsyncOnepasswordResource", + "OnepasswordResourceWithRawResponse", + "AsyncOnepasswordResourceWithRawResponse", + "OnepasswordResourceWithStreamingResponse", + "AsyncOnepasswordResourceWithStreamingResponse", "CredentialsResource", "AsyncCredentialsResource", "CredentialsResourceWithRawResponse", diff --git a/src/mobilerun_sdk/resources/credentials/credentials.py b/src/mobilerun_sdk/resources/credentials/credentials.py index 33a05947..bee33a0e 100644 --- a/src/mobilerun_sdk/resources/credentials/credentials.py +++ b/src/mobilerun_sdk/resources/credentials/credentials.py @@ -24,6 +24,14 @@ PackagesResourceWithStreamingResponse, AsyncPackagesResourceWithStreamingResponse, ) +from .onepassword.onepassword import ( + OnepasswordResource, + AsyncOnepasswordResource, + OnepasswordResourceWithRawResponse, + AsyncOnepasswordResourceWithRawResponse, + OnepasswordResourceWithStreamingResponse, + AsyncOnepasswordResourceWithStreamingResponse, +) from ...types.credential_list_response import CredentialListResponse __all__ = ["CredentialsResource", "AsyncCredentialsResource"] @@ -34,6 +42,10 @@ class CredentialsResource(SyncAPIResource): def packages(self) -> PackagesResource: return PackagesResource(self._client) + @cached_property + def onepassword(self) -> OnepasswordResource: + return OnepasswordResource(self._client) + @cached_property def with_raw_response(self) -> CredentialsResourceWithRawResponse: """ @@ -103,6 +115,10 @@ class AsyncCredentialsResource(AsyncAPIResource): def packages(self) -> AsyncPackagesResource: return AsyncPackagesResource(self._client) + @cached_property + def onepassword(self) -> AsyncOnepasswordResource: + return AsyncOnepasswordResource(self._client) + @cached_property def with_raw_response(self) -> AsyncCredentialsResourceWithRawResponse: """ @@ -179,6 +195,10 @@ def __init__(self, credentials: CredentialsResource) -> None: def packages(self) -> PackagesResourceWithRawResponse: return PackagesResourceWithRawResponse(self._credentials.packages) + @cached_property + def onepassword(self) -> OnepasswordResourceWithRawResponse: + return OnepasswordResourceWithRawResponse(self._credentials.onepassword) + class AsyncCredentialsResourceWithRawResponse: def __init__(self, credentials: AsyncCredentialsResource) -> None: @@ -192,6 +212,10 @@ def __init__(self, credentials: AsyncCredentialsResource) -> None: def packages(self) -> AsyncPackagesResourceWithRawResponse: return AsyncPackagesResourceWithRawResponse(self._credentials.packages) + @cached_property + def onepassword(self) -> AsyncOnepasswordResourceWithRawResponse: + return AsyncOnepasswordResourceWithRawResponse(self._credentials.onepassword) + class CredentialsResourceWithStreamingResponse: def __init__(self, credentials: CredentialsResource) -> None: @@ -205,6 +229,10 @@ def __init__(self, credentials: CredentialsResource) -> None: def packages(self) -> PackagesResourceWithStreamingResponse: return PackagesResourceWithStreamingResponse(self._credentials.packages) + @cached_property + def onepassword(self) -> OnepasswordResourceWithStreamingResponse: + return OnepasswordResourceWithStreamingResponse(self._credentials.onepassword) + class AsyncCredentialsResourceWithStreamingResponse: def __init__(self, credentials: AsyncCredentialsResource) -> None: @@ -217,3 +245,7 @@ def __init__(self, credentials: AsyncCredentialsResource) -> None: @cached_property def packages(self) -> AsyncPackagesResourceWithStreamingResponse: return AsyncPackagesResourceWithStreamingResponse(self._credentials.packages) + + @cached_property + def onepassword(self) -> AsyncOnepasswordResourceWithStreamingResponse: + return AsyncOnepasswordResourceWithStreamingResponse(self._credentials.onepassword) diff --git a/src/mobilerun_sdk/resources/credentials/onepassword/__init__.py b/src/mobilerun_sdk/resources/credentials/onepassword/__init__.py new file mode 100644 index 00000000..09c0157f --- /dev/null +++ b/src/mobilerun_sdk/resources/credentials/onepassword/__init__.py @@ -0,0 +1,33 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from .vaults import ( + VaultsResource, + AsyncVaultsResource, + VaultsResourceWithRawResponse, + AsyncVaultsResourceWithRawResponse, + VaultsResourceWithStreamingResponse, + AsyncVaultsResourceWithStreamingResponse, +) +from .onepassword import ( + OnepasswordResource, + AsyncOnepasswordResource, + OnepasswordResourceWithRawResponse, + AsyncOnepasswordResourceWithRawResponse, + OnepasswordResourceWithStreamingResponse, + AsyncOnepasswordResourceWithStreamingResponse, +) + +__all__ = [ + "VaultsResource", + "AsyncVaultsResource", + "VaultsResourceWithRawResponse", + "AsyncVaultsResourceWithRawResponse", + "VaultsResourceWithStreamingResponse", + "AsyncVaultsResourceWithStreamingResponse", + "OnepasswordResource", + "AsyncOnepasswordResource", + "OnepasswordResourceWithRawResponse", + "AsyncOnepasswordResourceWithRawResponse", + "OnepasswordResourceWithStreamingResponse", + "AsyncOnepasswordResourceWithStreamingResponse", +] diff --git a/src/mobilerun_sdk/resources/credentials/onepassword/onepassword.py b/src/mobilerun_sdk/resources/credentials/onepassword/onepassword.py new file mode 100644 index 00000000..6f5af779 --- /dev/null +++ b/src/mobilerun_sdk/resources/credentials/onepassword/onepassword.py @@ -0,0 +1,325 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +import httpx + +from ...._types import Body, Query, Headers, NotGiven, not_given +from ...._utils import maybe_transform, async_maybe_transform +from ...._compat import cached_property +from ...._resource import SyncAPIResource, AsyncAPIResource +from ...._response import ( + to_raw_response_wrapper, + to_streamed_response_wrapper, + async_to_raw_response_wrapper, + async_to_streamed_response_wrapper, +) +from .vaults.vaults import ( + VaultsResource, + AsyncVaultsResource, + VaultsResourceWithRawResponse, + AsyncVaultsResourceWithRawResponse, + VaultsResourceWithStreamingResponse, + AsyncVaultsResourceWithStreamingResponse, +) +from ...._base_client import make_request_options +from ....types.credentials import onepassword_connect_params +from ....types.credentials.onepassword_connect_response import OnepasswordConnectResponse +from ....types.credentials.onepassword_retrieve_response import OnepasswordRetrieveResponse +from ....types.credentials.onepassword_disconnect_response import OnepasswordDisconnectResponse + +__all__ = ["OnepasswordResource", "AsyncOnepasswordResource"] + + +class OnepasswordResource(SyncAPIResource): + @cached_property + def vaults(self) -> VaultsResource: + return VaultsResource(self._client) + + @cached_property + def with_raw_response(self) -> OnepasswordResourceWithRawResponse: + """ + This property can be used as a prefix for any HTTP method call to return + the raw response object instead of the parsed content. + + For more information, see https://www.github.com/droidrun/mobilerun-sdk-python#accessing-raw-response-data-eg-headers + """ + return OnepasswordResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> OnepasswordResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/droidrun/mobilerun-sdk-python#with_streaming_response + """ + return OnepasswordResourceWithStreamingResponse(self) + + def retrieve( + self, + *, + # 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, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> OnepasswordRetrieveResponse: + """Get 1Password connection""" + return self._get( + "/credentials/onepassword", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=OnepasswordRetrieveResponse, + ) + + def connect( + self, + *, + service_account_token: str, + # 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, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + idempotency_key: str | None = None, + ) -> OnepasswordConnectResponse: + """ + Connect a 1Password service account + + Args: + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + + idempotency_key: Specify a custom idempotency key for this request + """ + return self._put( + "/credentials/onepassword", + body=maybe_transform( + {"service_account_token": service_account_token}, onepassword_connect_params.OnepasswordConnectParams + ), + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + idempotency_key=idempotency_key, + ), + cast_to=OnepasswordConnectResponse, + ) + + def disconnect( + self, + *, + # 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, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + idempotency_key: str | None = None, + ) -> OnepasswordDisconnectResponse: + """Disconnect 1Password""" + return self._delete( + "/credentials/onepassword", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + idempotency_key=idempotency_key, + ), + cast_to=OnepasswordDisconnectResponse, + ) + + +class AsyncOnepasswordResource(AsyncAPIResource): + @cached_property + def vaults(self) -> AsyncVaultsResource: + return AsyncVaultsResource(self._client) + + @cached_property + def with_raw_response(self) -> AsyncOnepasswordResourceWithRawResponse: + """ + This property can be used as a prefix for any HTTP method call to return + the raw response object instead of the parsed content. + + For more information, see https://www.github.com/droidrun/mobilerun-sdk-python#accessing-raw-response-data-eg-headers + """ + return AsyncOnepasswordResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncOnepasswordResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/droidrun/mobilerun-sdk-python#with_streaming_response + """ + return AsyncOnepasswordResourceWithStreamingResponse(self) + + async def retrieve( + self, + *, + # 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, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> OnepasswordRetrieveResponse: + """Get 1Password connection""" + return await self._get( + "/credentials/onepassword", + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=OnepasswordRetrieveResponse, + ) + + async def connect( + self, + *, + service_account_token: str, + # 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, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + idempotency_key: str | None = None, + ) -> OnepasswordConnectResponse: + """ + Connect a 1Password service account + + Args: + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + + idempotency_key: Specify a custom idempotency key for this request + """ + return await self._put( + "/credentials/onepassword", + body=await async_maybe_transform( + {"service_account_token": service_account_token}, onepassword_connect_params.OnepasswordConnectParams + ), + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + idempotency_key=idempotency_key, + ), + cast_to=OnepasswordConnectResponse, + ) + + async def disconnect( + self, + *, + # 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, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + idempotency_key: str | None = None, + ) -> OnepasswordDisconnectResponse: + """Disconnect 1Password""" + return await self._delete( + "/credentials/onepassword", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + idempotency_key=idempotency_key, + ), + cast_to=OnepasswordDisconnectResponse, + ) + + +class OnepasswordResourceWithRawResponse: + def __init__(self, onepassword: OnepasswordResource) -> None: + self._onepassword = onepassword + + self.retrieve = to_raw_response_wrapper( + onepassword.retrieve, + ) + self.connect = to_raw_response_wrapper( + onepassword.connect, + ) + self.disconnect = to_raw_response_wrapper( + onepassword.disconnect, + ) + + @cached_property + def vaults(self) -> VaultsResourceWithRawResponse: + return VaultsResourceWithRawResponse(self._onepassword.vaults) + + +class AsyncOnepasswordResourceWithRawResponse: + def __init__(self, onepassword: AsyncOnepasswordResource) -> None: + self._onepassword = onepassword + + self.retrieve = async_to_raw_response_wrapper( + onepassword.retrieve, + ) + self.connect = async_to_raw_response_wrapper( + onepassword.connect, + ) + self.disconnect = async_to_raw_response_wrapper( + onepassword.disconnect, + ) + + @cached_property + def vaults(self) -> AsyncVaultsResourceWithRawResponse: + return AsyncVaultsResourceWithRawResponse(self._onepassword.vaults) + + +class OnepasswordResourceWithStreamingResponse: + def __init__(self, onepassword: OnepasswordResource) -> None: + self._onepassword = onepassword + + self.retrieve = to_streamed_response_wrapper( + onepassword.retrieve, + ) + self.connect = to_streamed_response_wrapper( + onepassword.connect, + ) + self.disconnect = to_streamed_response_wrapper( + onepassword.disconnect, + ) + + @cached_property + def vaults(self) -> VaultsResourceWithStreamingResponse: + return VaultsResourceWithStreamingResponse(self._onepassword.vaults) + + +class AsyncOnepasswordResourceWithStreamingResponse: + def __init__(self, onepassword: AsyncOnepasswordResource) -> None: + self._onepassword = onepassword + + self.retrieve = async_to_streamed_response_wrapper( + onepassword.retrieve, + ) + self.connect = async_to_streamed_response_wrapper( + onepassword.connect, + ) + self.disconnect = async_to_streamed_response_wrapper( + onepassword.disconnect, + ) + + @cached_property + def vaults(self) -> AsyncVaultsResourceWithStreamingResponse: + return AsyncVaultsResourceWithStreamingResponse(self._onepassword.vaults) diff --git a/src/mobilerun_sdk/resources/credentials/onepassword/vaults/__init__.py b/src/mobilerun_sdk/resources/credentials/onepassword/vaults/__init__.py new file mode 100644 index 00000000..a019b7ee --- /dev/null +++ b/src/mobilerun_sdk/resources/credentials/onepassword/vaults/__init__.py @@ -0,0 +1,33 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from .items import ( + ItemsResource, + AsyncItemsResource, + ItemsResourceWithRawResponse, + AsyncItemsResourceWithRawResponse, + ItemsResourceWithStreamingResponse, + AsyncItemsResourceWithStreamingResponse, +) +from .vaults import ( + VaultsResource, + AsyncVaultsResource, + VaultsResourceWithRawResponse, + AsyncVaultsResourceWithRawResponse, + VaultsResourceWithStreamingResponse, + AsyncVaultsResourceWithStreamingResponse, +) + +__all__ = [ + "ItemsResource", + "AsyncItemsResource", + "ItemsResourceWithRawResponse", + "AsyncItemsResourceWithRawResponse", + "ItemsResourceWithStreamingResponse", + "AsyncItemsResourceWithStreamingResponse", + "VaultsResource", + "AsyncVaultsResource", + "VaultsResourceWithRawResponse", + "AsyncVaultsResourceWithRawResponse", + "VaultsResourceWithStreamingResponse", + "AsyncVaultsResourceWithStreamingResponse", +] diff --git a/src/mobilerun_sdk/resources/credentials/onepassword/vaults/items/__init__.py b/src/mobilerun_sdk/resources/credentials/onepassword/vaults/items/__init__.py new file mode 100644 index 00000000..3da46ff8 --- /dev/null +++ b/src/mobilerun_sdk/resources/credentials/onepassword/vaults/items/__init__.py @@ -0,0 +1,33 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from .items import ( + ItemsResource, + AsyncItemsResource, + ItemsResourceWithRawResponse, + AsyncItemsResourceWithRawResponse, + ItemsResourceWithStreamingResponse, + AsyncItemsResourceWithStreamingResponse, +) +from .fields import ( + FieldsResource, + AsyncFieldsResource, + FieldsResourceWithRawResponse, + AsyncFieldsResourceWithRawResponse, + FieldsResourceWithStreamingResponse, + AsyncFieldsResourceWithStreamingResponse, +) + +__all__ = [ + "FieldsResource", + "AsyncFieldsResource", + "FieldsResourceWithRawResponse", + "AsyncFieldsResourceWithRawResponse", + "FieldsResourceWithStreamingResponse", + "AsyncFieldsResourceWithStreamingResponse", + "ItemsResource", + "AsyncItemsResource", + "ItemsResourceWithRawResponse", + "AsyncItemsResourceWithRawResponse", + "ItemsResourceWithStreamingResponse", + "AsyncItemsResourceWithStreamingResponse", +] diff --git a/src/mobilerun_sdk/resources/credentials/onepassword/vaults/items/fields.py b/src/mobilerun_sdk/resources/credentials/onepassword/vaults/items/fields.py new file mode 100644 index 00000000..9dea3c78 --- /dev/null +++ b/src/mobilerun_sdk/resources/credentials/onepassword/vaults/items/fields.py @@ -0,0 +1,174 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +import httpx + +from ......_types import Body, Query, Headers, NotGiven, not_given +from ......_utils import path_template +from ......_compat import cached_property +from ......_resource import SyncAPIResource, AsyncAPIResource +from ......_response import ( + to_raw_response_wrapper, + to_streamed_response_wrapper, + async_to_raw_response_wrapper, + async_to_streamed_response_wrapper, +) +from ......_base_client import make_request_options +from ......types.credentials.onepassword.vaults.items.field_list_response import FieldListResponse + +__all__ = ["FieldsResource", "AsyncFieldsResource"] + + +class FieldsResource(SyncAPIResource): + @cached_property + def with_raw_response(self) -> FieldsResourceWithRawResponse: + """ + This property can be used as a prefix for any HTTP method call to return + the raw response object instead of the parsed content. + + For more information, see https://www.github.com/droidrun/mobilerun-sdk-python#accessing-raw-response-data-eg-headers + """ + return FieldsResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> FieldsResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/droidrun/mobilerun-sdk-python#with_streaming_response + """ + return FieldsResourceWithStreamingResponse(self) + + def list( + self, + item_id: str, + *, + vault_id: str, + # 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, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> FieldListResponse: + """ + List 1Password field metadata + + Args: + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + if not vault_id: + raise ValueError(f"Expected a non-empty value for `vault_id` but received {vault_id!r}") + if not item_id: + raise ValueError(f"Expected a non-empty value for `item_id` but received {item_id!r}") + return self._get( + path_template( + "/credentials/onepassword/vaults/{vault_id}/items/{item_id}/fields", vault_id=vault_id, item_id=item_id + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=FieldListResponse, + ) + + +class AsyncFieldsResource(AsyncAPIResource): + @cached_property + def with_raw_response(self) -> AsyncFieldsResourceWithRawResponse: + """ + This property can be used as a prefix for any HTTP method call to return + the raw response object instead of the parsed content. + + For more information, see https://www.github.com/droidrun/mobilerun-sdk-python#accessing-raw-response-data-eg-headers + """ + return AsyncFieldsResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncFieldsResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/droidrun/mobilerun-sdk-python#with_streaming_response + """ + return AsyncFieldsResourceWithStreamingResponse(self) + + async def list( + self, + item_id: str, + *, + vault_id: str, + # 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, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> FieldListResponse: + """ + List 1Password field metadata + + Args: + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + if not vault_id: + raise ValueError(f"Expected a non-empty value for `vault_id` but received {vault_id!r}") + if not item_id: + raise ValueError(f"Expected a non-empty value for `item_id` but received {item_id!r}") + return await self._get( + path_template( + "/credentials/onepassword/vaults/{vault_id}/items/{item_id}/fields", vault_id=vault_id, item_id=item_id + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=FieldListResponse, + ) + + +class FieldsResourceWithRawResponse: + def __init__(self, fields: FieldsResource) -> None: + self._fields = fields + + self.list = to_raw_response_wrapper( + fields.list, + ) + + +class AsyncFieldsResourceWithRawResponse: + def __init__(self, fields: AsyncFieldsResource) -> None: + self._fields = fields + + self.list = async_to_raw_response_wrapper( + fields.list, + ) + + +class FieldsResourceWithStreamingResponse: + def __init__(self, fields: FieldsResource) -> None: + self._fields = fields + + self.list = to_streamed_response_wrapper( + fields.list, + ) + + +class AsyncFieldsResourceWithStreamingResponse: + def __init__(self, fields: AsyncFieldsResource) -> None: + self._fields = fields + + self.list = async_to_streamed_response_wrapper( + fields.list, + ) diff --git a/src/mobilerun_sdk/resources/credentials/onepassword/vaults/items/items.py b/src/mobilerun_sdk/resources/credentials/onepassword/vaults/items/items.py new file mode 100644 index 00000000..15c1f90e --- /dev/null +++ b/src/mobilerun_sdk/resources/credentials/onepassword/vaults/items/items.py @@ -0,0 +1,196 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +import httpx + +from .fields import ( + FieldsResource, + AsyncFieldsResource, + FieldsResourceWithRawResponse, + AsyncFieldsResourceWithRawResponse, + FieldsResourceWithStreamingResponse, + AsyncFieldsResourceWithStreamingResponse, +) +from ......_types import Body, Query, Headers, NotGiven, not_given +from ......_utils import path_template +from ......_compat import cached_property +from ......_resource import SyncAPIResource, AsyncAPIResource +from ......_response import ( + to_raw_response_wrapper, + to_streamed_response_wrapper, + async_to_raw_response_wrapper, + async_to_streamed_response_wrapper, +) +from ......_base_client import make_request_options +from ......types.credentials.onepassword.vaults.item_list_response import ItemListResponse + +__all__ = ["ItemsResource", "AsyncItemsResource"] + + +class ItemsResource(SyncAPIResource): + @cached_property + def fields(self) -> FieldsResource: + return FieldsResource(self._client) + + @cached_property + def with_raw_response(self) -> ItemsResourceWithRawResponse: + """ + This property can be used as a prefix for any HTTP method call to return + the raw response object instead of the parsed content. + + For more information, see https://www.github.com/droidrun/mobilerun-sdk-python#accessing-raw-response-data-eg-headers + """ + return ItemsResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> ItemsResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/droidrun/mobilerun-sdk-python#with_streaming_response + """ + return ItemsResourceWithStreamingResponse(self) + + def list( + self, + vault_id: str, + *, + # 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, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> ItemListResponse: + """ + List 1Password item metadata + + Args: + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + if not vault_id: + raise ValueError(f"Expected a non-empty value for `vault_id` but received {vault_id!r}") + return self._get( + path_template("/credentials/onepassword/vaults/{vault_id}/items", vault_id=vault_id), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=ItemListResponse, + ) + + +class AsyncItemsResource(AsyncAPIResource): + @cached_property + def fields(self) -> AsyncFieldsResource: + return AsyncFieldsResource(self._client) + + @cached_property + def with_raw_response(self) -> AsyncItemsResourceWithRawResponse: + """ + This property can be used as a prefix for any HTTP method call to return + the raw response object instead of the parsed content. + + For more information, see https://www.github.com/droidrun/mobilerun-sdk-python#accessing-raw-response-data-eg-headers + """ + return AsyncItemsResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncItemsResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/droidrun/mobilerun-sdk-python#with_streaming_response + """ + return AsyncItemsResourceWithStreamingResponse(self) + + async def list( + self, + vault_id: str, + *, + # 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, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> ItemListResponse: + """ + List 1Password item metadata + + Args: + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + """ + if not vault_id: + raise ValueError(f"Expected a non-empty value for `vault_id` but received {vault_id!r}") + return await self._get( + path_template("/credentials/onepassword/vaults/{vault_id}/items", vault_id=vault_id), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=ItemListResponse, + ) + + +class ItemsResourceWithRawResponse: + def __init__(self, items: ItemsResource) -> None: + self._items = items + + self.list = to_raw_response_wrapper( + items.list, + ) + + @cached_property + def fields(self) -> FieldsResourceWithRawResponse: + return FieldsResourceWithRawResponse(self._items.fields) + + +class AsyncItemsResourceWithRawResponse: + def __init__(self, items: AsyncItemsResource) -> None: + self._items = items + + self.list = async_to_raw_response_wrapper( + items.list, + ) + + @cached_property + def fields(self) -> AsyncFieldsResourceWithRawResponse: + return AsyncFieldsResourceWithRawResponse(self._items.fields) + + +class ItemsResourceWithStreamingResponse: + def __init__(self, items: ItemsResource) -> None: + self._items = items + + self.list = to_streamed_response_wrapper( + items.list, + ) + + @cached_property + def fields(self) -> FieldsResourceWithStreamingResponse: + return FieldsResourceWithStreamingResponse(self._items.fields) + + +class AsyncItemsResourceWithStreamingResponse: + def __init__(self, items: AsyncItemsResource) -> None: + self._items = items + + self.list = async_to_streamed_response_wrapper( + items.list, + ) + + @cached_property + def fields(self) -> AsyncFieldsResourceWithStreamingResponse: + return AsyncFieldsResourceWithStreamingResponse(self._items.fields) diff --git a/src/mobilerun_sdk/resources/credentials/onepassword/vaults/vaults.py b/src/mobilerun_sdk/resources/credentials/onepassword/vaults/vaults.py new file mode 100644 index 00000000..e26d434b --- /dev/null +++ b/src/mobilerun_sdk/resources/credentials/onepassword/vaults/vaults.py @@ -0,0 +1,102 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from ....._compat import cached_property +from .items.items import ( + ItemsResource, + AsyncItemsResource, + ItemsResourceWithRawResponse, + AsyncItemsResourceWithRawResponse, + ItemsResourceWithStreamingResponse, + AsyncItemsResourceWithStreamingResponse, +) +from ....._resource import SyncAPIResource, AsyncAPIResource + +__all__ = ["VaultsResource", "AsyncVaultsResource"] + + +class VaultsResource(SyncAPIResource): + @cached_property + def items(self) -> ItemsResource: + return ItemsResource(self._client) + + @cached_property + def with_raw_response(self) -> VaultsResourceWithRawResponse: + """ + This property can be used as a prefix for any HTTP method call to return + the raw response object instead of the parsed content. + + For more information, see https://www.github.com/droidrun/mobilerun-sdk-python#accessing-raw-response-data-eg-headers + """ + return VaultsResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> VaultsResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/droidrun/mobilerun-sdk-python#with_streaming_response + """ + return VaultsResourceWithStreamingResponse(self) + + +class AsyncVaultsResource(AsyncAPIResource): + @cached_property + def items(self) -> AsyncItemsResource: + return AsyncItemsResource(self._client) + + @cached_property + def with_raw_response(self) -> AsyncVaultsResourceWithRawResponse: + """ + This property can be used as a prefix for any HTTP method call to return + the raw response object instead of the parsed content. + + For more information, see https://www.github.com/droidrun/mobilerun-sdk-python#accessing-raw-response-data-eg-headers + """ + return AsyncVaultsResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncVaultsResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/droidrun/mobilerun-sdk-python#with_streaming_response + """ + return AsyncVaultsResourceWithStreamingResponse(self) + + +class VaultsResourceWithRawResponse: + def __init__(self, vaults: VaultsResource) -> None: + self._vaults = vaults + + @cached_property + def items(self) -> ItemsResourceWithRawResponse: + return ItemsResourceWithRawResponse(self._vaults.items) + + +class AsyncVaultsResourceWithRawResponse: + def __init__(self, vaults: AsyncVaultsResource) -> None: + self._vaults = vaults + + @cached_property + def items(self) -> AsyncItemsResourceWithRawResponse: + return AsyncItemsResourceWithRawResponse(self._vaults.items) + + +class VaultsResourceWithStreamingResponse: + def __init__(self, vaults: VaultsResource) -> None: + self._vaults = vaults + + @cached_property + def items(self) -> ItemsResourceWithStreamingResponse: + return ItemsResourceWithStreamingResponse(self._vaults.items) + + +class AsyncVaultsResourceWithStreamingResponse: + def __init__(self, vaults: AsyncVaultsResource) -> None: + self._vaults = vaults + + @cached_property + def items(self) -> AsyncItemsResourceWithStreamingResponse: + return AsyncItemsResourceWithStreamingResponse(self._vaults.items) diff --git a/src/mobilerun_sdk/resources/credentials/packages/__init__.py b/src/mobilerun_sdk/resources/credentials/packages/__init__.py index 179ec4af..07b6c22c 100644 --- a/src/mobilerun_sdk/resources/credentials/packages/__init__.py +++ b/src/mobilerun_sdk/resources/credentials/packages/__init__.py @@ -1,5 +1,13 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. +from .links import ( + LinksResource, + AsyncLinksResource, + LinksResourceWithRawResponse, + AsyncLinksResourceWithRawResponse, + LinksResourceWithStreamingResponse, + AsyncLinksResourceWithStreamingResponse, +) from .packages import ( PackagesResource, AsyncPackagesResource, @@ -24,6 +32,12 @@ "AsyncCredentialsResourceWithRawResponse", "CredentialsResourceWithStreamingResponse", "AsyncCredentialsResourceWithStreamingResponse", + "LinksResource", + "AsyncLinksResource", + "LinksResourceWithRawResponse", + "AsyncLinksResourceWithRawResponse", + "LinksResourceWithStreamingResponse", + "AsyncLinksResourceWithStreamingResponse", "PackagesResource", "AsyncPackagesResource", "PackagesResourceWithRawResponse", diff --git a/src/mobilerun_sdk/resources/credentials/packages/credentials/credentials.py b/src/mobilerun_sdk/resources/credentials/packages/credentials/credentials.py index 80de6019..c05b9f9a 100644 --- a/src/mobilerun_sdk/resources/credentials/packages/credentials/credentials.py +++ b/src/mobilerun_sdk/resources/credentials/packages/credentials/credentials.py @@ -28,7 +28,6 @@ from .....types.credentials.packages import credential_create_params from .....types.credentials.packages.credential_create_response import CredentialCreateResponse from .....types.credentials.packages.credential_delete_response import CredentialDeleteResponse -from .....types.credentials.packages.credential_retrieve_response import CredentialRetrieveResponse __all__ = ["CredentialsResource", "AsyncCredentialsResource"] @@ -108,47 +107,6 @@ def create( cast_to=CredentialCreateResponse, ) - def retrieve( - self, - credential_name: str, - *, - package_name: str, - # 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, - extra_query: Query | None = None, - extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = not_given, - ) -> CredentialRetrieveResponse: - """ - Fetches a single credential by `packageName` and `credentialName`, including all - of its stored fields. Returns not found if no matching credential exists. - - Args: - extra_headers: Send extra headers - - extra_query: Add additional query parameters to the request - - extra_body: Add additional JSON properties to the request - - timeout: Override the client-level default timeout for this request, in seconds - """ - if not package_name: - raise ValueError(f"Expected a non-empty value for `package_name` but received {package_name!r}") - if not credential_name: - raise ValueError(f"Expected a non-empty value for `credential_name` but received {credential_name!r}") - return self._get( - path_template( - "/credentials/packages/{package_name}/credentials/{credential_name}", - package_name=package_name, - credential_name=credential_name, - ), - options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout - ), - cast_to=CredentialRetrieveResponse, - ) - def delete( self, credential_name: str, @@ -273,47 +231,6 @@ async def create( cast_to=CredentialCreateResponse, ) - async def retrieve( - self, - credential_name: str, - *, - package_name: str, - # 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, - extra_query: Query | None = None, - extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = not_given, - ) -> CredentialRetrieveResponse: - """ - Fetches a single credential by `packageName` and `credentialName`, including all - of its stored fields. Returns not found if no matching credential exists. - - Args: - extra_headers: Send extra headers - - extra_query: Add additional query parameters to the request - - extra_body: Add additional JSON properties to the request - - timeout: Override the client-level default timeout for this request, in seconds - """ - if not package_name: - raise ValueError(f"Expected a non-empty value for `package_name` but received {package_name!r}") - if not credential_name: - raise ValueError(f"Expected a non-empty value for `credential_name` but received {credential_name!r}") - return await self._get( - path_template( - "/credentials/packages/{package_name}/credentials/{credential_name}", - package_name=package_name, - credential_name=credential_name, - ), - options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout - ), - cast_to=CredentialRetrieveResponse, - ) - async def delete( self, credential_name: str, @@ -370,9 +287,6 @@ def __init__(self, credentials: CredentialsResource) -> None: self.create = to_raw_response_wrapper( credentials.create, ) - self.retrieve = to_raw_response_wrapper( - credentials.retrieve, - ) self.delete = to_raw_response_wrapper( credentials.delete, ) @@ -389,9 +303,6 @@ def __init__(self, credentials: AsyncCredentialsResource) -> None: self.create = async_to_raw_response_wrapper( credentials.create, ) - self.retrieve = async_to_raw_response_wrapper( - credentials.retrieve, - ) self.delete = async_to_raw_response_wrapper( credentials.delete, ) @@ -408,9 +319,6 @@ def __init__(self, credentials: CredentialsResource) -> None: self.create = to_streamed_response_wrapper( credentials.create, ) - self.retrieve = to_streamed_response_wrapper( - credentials.retrieve, - ) self.delete = to_streamed_response_wrapper( credentials.delete, ) @@ -427,9 +335,6 @@ def __init__(self, credentials: AsyncCredentialsResource) -> None: self.create = async_to_streamed_response_wrapper( credentials.create, ) - self.retrieve = async_to_streamed_response_wrapper( - credentials.retrieve, - ) self.delete = async_to_streamed_response_wrapper( credentials.delete, ) diff --git a/src/mobilerun_sdk/resources/credentials/packages/links.py b/src/mobilerun_sdk/resources/credentials/packages/links.py new file mode 100644 index 00000000..019fae21 --- /dev/null +++ b/src/mobilerun_sdk/resources/credentials/packages/links.py @@ -0,0 +1,207 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Iterable + +import httpx + +from ...._types import Body, Query, Headers, NotGiven, not_given +from ...._utils import path_template, maybe_transform, async_maybe_transform +from ...._compat import cached_property +from ...._resource import SyncAPIResource, AsyncAPIResource +from ...._response import ( + to_raw_response_wrapper, + to_streamed_response_wrapper, + async_to_raw_response_wrapper, + async_to_streamed_response_wrapper, +) +from ...._base_client import make_request_options +from ....types.credentials.packages import link_create_params +from ....types.credentials.packages.link_create_response import LinkCreateResponse + +__all__ = ["LinksResource", "AsyncLinksResource"] + + +class LinksResource(SyncAPIResource): + @cached_property + def with_raw_response(self) -> LinksResourceWithRawResponse: + """ + This property can be used as a prefix for any HTTP method call to return + the raw response object instead of the parsed content. + + For more information, see https://www.github.com/droidrun/mobilerun-sdk-python#accessing-raw-response-data-eg-headers + """ + return LinksResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> LinksResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/droidrun/mobilerun-sdk-python#with_streaming_response + """ + return LinksResourceWithStreamingResponse(self) + + def create( + self, + package_name: str, + *, + credential_name: str, + field_map: Iterable[link_create_params.FieldMap], + item_id: str, + vault_id: str, + # 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, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + idempotency_key: str | None = None, + ) -> LinkCreateResponse: + """ + Link a 1Password item to a credential + + Args: + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + + idempotency_key: Specify a custom idempotency key for this request + """ + if not package_name: + raise ValueError(f"Expected a non-empty value for `package_name` but received {package_name!r}") + return self._post( + path_template("/credentials/packages/{package_name}/links", package_name=package_name), + body=maybe_transform( + { + "credential_name": credential_name, + "field_map": field_map, + "item_id": item_id, + "vault_id": vault_id, + }, + link_create_params.LinkCreateParams, + ), + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + idempotency_key=idempotency_key, + ), + cast_to=LinkCreateResponse, + ) + + +class AsyncLinksResource(AsyncAPIResource): + @cached_property + def with_raw_response(self) -> AsyncLinksResourceWithRawResponse: + """ + This property can be used as a prefix for any HTTP method call to return + the raw response object instead of the parsed content. + + For more information, see https://www.github.com/droidrun/mobilerun-sdk-python#accessing-raw-response-data-eg-headers + """ + return AsyncLinksResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncLinksResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/droidrun/mobilerun-sdk-python#with_streaming_response + """ + return AsyncLinksResourceWithStreamingResponse(self) + + async def create( + self, + package_name: str, + *, + credential_name: str, + field_map: Iterable[link_create_params.FieldMap], + item_id: str, + vault_id: str, + # 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, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + idempotency_key: str | None = None, + ) -> LinkCreateResponse: + """ + Link a 1Password item to a credential + + Args: + extra_headers: Send extra headers + + extra_query: Add additional query parameters to the request + + extra_body: Add additional JSON properties to the request + + timeout: Override the client-level default timeout for this request, in seconds + + idempotency_key: Specify a custom idempotency key for this request + """ + if not package_name: + raise ValueError(f"Expected a non-empty value for `package_name` but received {package_name!r}") + return await self._post( + path_template("/credentials/packages/{package_name}/links", package_name=package_name), + body=await async_maybe_transform( + { + "credential_name": credential_name, + "field_map": field_map, + "item_id": item_id, + "vault_id": vault_id, + }, + link_create_params.LinkCreateParams, + ), + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + idempotency_key=idempotency_key, + ), + cast_to=LinkCreateResponse, + ) + + +class LinksResourceWithRawResponse: + def __init__(self, links: LinksResource) -> None: + self._links = links + + self.create = to_raw_response_wrapper( + links.create, + ) + + +class AsyncLinksResourceWithRawResponse: + def __init__(self, links: AsyncLinksResource) -> None: + self._links = links + + self.create = async_to_raw_response_wrapper( + links.create, + ) + + +class LinksResourceWithStreamingResponse: + def __init__(self, links: LinksResource) -> None: + self._links = links + + self.create = to_streamed_response_wrapper( + links.create, + ) + + +class AsyncLinksResourceWithStreamingResponse: + def __init__(self, links: AsyncLinksResource) -> None: + self._links = links + + self.create = async_to_streamed_response_wrapper( + links.create, + ) diff --git a/src/mobilerun_sdk/resources/credentials/packages/packages.py b/src/mobilerun_sdk/resources/credentials/packages/packages.py index 3476d7f5..ebdad725 100644 --- a/src/mobilerun_sdk/resources/credentials/packages/packages.py +++ b/src/mobilerun_sdk/resources/credentials/packages/packages.py @@ -4,6 +4,14 @@ import httpx +from .links import ( + LinksResource, + AsyncLinksResource, + LinksResourceWithRawResponse, + AsyncLinksResourceWithRawResponse, + LinksResourceWithStreamingResponse, + AsyncLinksResourceWithStreamingResponse, +) from ...._types import Body, Query, Headers, NotGiven, not_given from ...._utils import path_template, maybe_transform, async_maybe_transform from ...._compat import cached_property @@ -36,6 +44,10 @@ class PackagesResource(SyncAPIResource): def credentials(self) -> CredentialsResource: return CredentialsResource(self._client) + @cached_property + def links(self) -> LinksResource: + return LinksResource(self._client) + @cached_property def with_raw_response(self) -> PackagesResourceWithRawResponse: """ @@ -160,6 +172,10 @@ class AsyncPackagesResource(AsyncAPIResource): def credentials(self) -> AsyncCredentialsResource: return AsyncCredentialsResource(self._client) + @cached_property + def links(self) -> AsyncLinksResource: + return AsyncLinksResource(self._client) + @cached_property def with_raw_response(self) -> AsyncPackagesResourceWithRawResponse: """ @@ -297,6 +313,10 @@ def __init__(self, packages: PackagesResource) -> None: def credentials(self) -> CredentialsResourceWithRawResponse: return CredentialsResourceWithRawResponse(self._packages.credentials) + @cached_property + def links(self) -> LinksResourceWithRawResponse: + return LinksResourceWithRawResponse(self._packages.links) + class AsyncPackagesResourceWithRawResponse: def __init__(self, packages: AsyncPackagesResource) -> None: @@ -316,6 +336,10 @@ def __init__(self, packages: AsyncPackagesResource) -> None: def credentials(self) -> AsyncCredentialsResourceWithRawResponse: return AsyncCredentialsResourceWithRawResponse(self._packages.credentials) + @cached_property + def links(self) -> AsyncLinksResourceWithRawResponse: + return AsyncLinksResourceWithRawResponse(self._packages.links) + class PackagesResourceWithStreamingResponse: def __init__(self, packages: PackagesResource) -> None: @@ -335,6 +359,10 @@ def __init__(self, packages: PackagesResource) -> None: def credentials(self) -> CredentialsResourceWithStreamingResponse: return CredentialsResourceWithStreamingResponse(self._packages.credentials) + @cached_property + def links(self) -> LinksResourceWithStreamingResponse: + return LinksResourceWithStreamingResponse(self._packages.links) + class AsyncPackagesResourceWithStreamingResponse: def __init__(self, packages: AsyncPackagesResource) -> None: @@ -353,3 +381,7 @@ def __init__(self, packages: AsyncPackagesResource) -> None: @cached_property def credentials(self) -> AsyncCredentialsResourceWithStreamingResponse: return AsyncCredentialsResourceWithStreamingResponse(self._packages.credentials) + + @cached_property + def links(self) -> AsyncLinksResourceWithStreamingResponse: + return AsyncLinksResourceWithStreamingResponse(self._packages.links) diff --git a/src/mobilerun_sdk/resources/devices/devices.py b/src/mobilerun_sdk/resources/devices/devices.py index 6c589685..d33cd3bb 100644 --- a/src/mobilerun_sdk/resources/devices/devices.py +++ b/src/mobilerun_sdk/resources/devices/devices.py @@ -309,8 +309,9 @@ def create( *, billing: Literal["auto", "subscription", "minute"] | Omit = omit, query_country: str | Omit = omit, - device_type: str | Omit = omit, + device_type: Literal["android_cloud_phone", "ios_phone", "device_slot"] | Omit = omit, profile_id: str | Omit = omit, + template: str | Omit = omit, android_version: int | Omit = omit, apps: Optional[SequenceNotStr[str]] | Omit = omit, carrier: DeviceCarrier | Omit = omit, @@ -349,13 +350,19 @@ def create( query_country: ISO 3166-1 alpha-2 country code. If omitted the system picks the country with the most availability. - device_type: Use android*cloud_phone for a cloud Android phone. Only canonical identifiers - are accepted. Other backends are deployment-specific; recognized but unavailable - types return DEVICE_TYPE_UNAVAILABLE (422). Retired dedicated*\\** aliases are - rejected with a canonical replacement. + device_type: Device type: android_cloud_phone (cloud Android phone), ios_phone or + device_slot. Any other value is rejected with 422. Not every device type is + available for creation; an unavailable type returns DEVICE_TYPE_UNAVAILABLE + (422). profile_id: Profile ID to use as device spec + template: Optional device template, e.g. onboarding. The device gets the template's + Android version and preinstalled apps and is ready in seconds when a prepared + phone is available; otherwise it boots with the same setup. Country, name and + proxy still come from this request. Cannot be combined with profileId, apps or + androidVersion. Omit it to create from the request alone. + extra_headers: Send extra headers extra_query: Add additional query parameters to the request @@ -396,6 +403,7 @@ def create( "query_country": query_country, "device_type": device_type, "profile_id": profile_id, + "template": template, }, device_create_params.DeviceCreateParams, ), @@ -471,15 +479,7 @@ def list( ] ] | Omit = omit, - type: Literal[ - "android_cloud_phone", - "android_physical_phone", - "ios_stealth_phone", - "android_emulator", - "ios_simulator", - "device_slot", - ] - | Omit = omit, + type: Literal["android_cloud_phone", "ios_phone", "device_slot"] | Omit = omit, # 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, @@ -504,8 +504,7 @@ def list( mine: When true, only return devices created by the authenticated caller. - platform: Filter by the device's platform as served in the platform field (runtime, - announced, else type-derived). + platform: Filter by the device's platform as served in the platform field. search: Case-insensitive search: matches devices whose name contains the term or whose ID starts with it. Combined with all other filters. @@ -514,8 +513,7 @@ def list( to every state except terminated and unknown, so stopped and maintenance devices are listed; pass state=terminated or state=unknown to see those. - type: Canonical device type. Retired dedicated\\__\\** aliases are no longer accepted. - Availability depends on the deployment. + type: Filter by device type. extra_headers: Send extra headers @@ -638,7 +636,10 @@ def reboot( """Triggers a reboot of the device. The device transitions through its reboot - lifecycle and becomes ready again once the restart completes. + lifecycle and becomes ready again once the restart completes. Only devices whose + capabilities report `reboot=true` can be rebooted. Personal (BYOD) devices + cannot be rebooted remotely: the request is refused with 400 + `DEVICE_TOOL_UNSUPPORTED` and nothing happens on the device. Args: extra_headers: Send extra headers @@ -671,6 +672,7 @@ def reset( device_id: str, *, mode: Literal["full", "identity"] | Omit = omit, + preserve: Optional[List[Literal["proxy", "location", "locale", "timezone"]]] | Omit = omit, # 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, @@ -681,16 +683,13 @@ def reset( ) -> None: """Resets the device. - The optional body `mode` selects what is erased: `full` is a - factory reset that erases installed apps, accounts and storage and gives the - device a new identity; `identity` gives the device a new fingerprint and keeps - its apps and data. When `mode` is omitted the reset is `full`, or `identity` on - devices whose capabilities report `factoryReset=false`. A mode the device does - not support (see `factoryReset` / `identityReset` in the device capabilities) is - refused with 400 `DEVICE_TOOL_UNSUPPORTED`; legacy devices accept an explicit - mode only when it is the one their capabilities advertise, and always accept a - reset without a mode. The device transitions through its reset lifecycle before - becoming ready again. + `mode` selects what is erased: `full` (factory reset: apps, + accounts, storage, new identity) or `identity` (new fingerprint, apps and data + kept). Without `mode` the reset is `full`, or `identity` on devices with + `factoryReset=false`. A mode or `preserve` value the device does not support is + refused with 400 `DEVICE_TOOL_UNSUPPORTED`. `preserve` restores the latest + proxy, location, locale or timezone set through the API after the reset; omitted + or empty preserves nothing. The device becomes ready again after the reset. Args: mode: What to erase. full: factory reset — erases the user data (apps, accounts, @@ -698,6 +697,9 @@ def reset( apps and data are kept. When omitted: full, or identity on devices whose capabilities report factoryReset=false. + preserve: Device configuration to restore after the reset: the latest value set through + the API. Omitted, null or empty preserves nothing. + extra_headers: Send extra headers extra_query: Add additional query parameters to the request @@ -713,7 +715,13 @@ def reset( extra_headers = {"Accept": "*/*", **(extra_headers or {})} return self._post( path_template("/devices/{device_id}/reset", device_id=device_id), - body=maybe_transform({"mode": mode}, device_reset_params.DeviceResetParams), + body=maybe_transform( + { + "mode": mode, + "preserve": preserve, + }, + device_reset_params.DeviceResetParams, + ), options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, @@ -737,9 +745,9 @@ def resume( idempotency_key: str | None = None, ) -> None: """ - Wakes a parked device: backend readiness and any required capacity are - preflighted, the same device starts running again, and per-minute billing - resumes. On a device that is not parked this is a no-op ready transition. + Wakes a parked device: it first checks that the device can run again, then the + same device starts and per-minute billing resumes. On a device that is not + parked, the request does nothing. Args: extra_headers: Send extra headers @@ -956,9 +964,13 @@ def terminate( ) -> None: """Terminates the device and releases its resources. - The optional `terminateAt` and - `previousDeviceId` body fields are not available to API-key callers; requests - that set them are rejected with 401. + For a personal (BYOD) device + the owner (API key or user) can instead remove the phone from the account so + anyone can pair it again; the phone must be disconnected first, otherwise the + request is rejected with 409 BYOD_DEVICE_CONNECTED. Other subscription-billed + devices cannot be terminated with this request; it is rejected with 401. The + `terminateAt` and `previousDeviceId` body fields are reserved for internal use; + requests that set them are rejected with 401. Args: extra_headers: Send extra headers @@ -1134,8 +1146,9 @@ async def create( *, billing: Literal["auto", "subscription", "minute"] | Omit = omit, query_country: str | Omit = omit, - device_type: str | Omit = omit, + device_type: Literal["android_cloud_phone", "ios_phone", "device_slot"] | Omit = omit, profile_id: str | Omit = omit, + template: str | Omit = omit, android_version: int | Omit = omit, apps: Optional[SequenceNotStr[str]] | Omit = omit, carrier: DeviceCarrier | Omit = omit, @@ -1174,13 +1187,19 @@ async def create( query_country: ISO 3166-1 alpha-2 country code. If omitted the system picks the country with the most availability. - device_type: Use android*cloud_phone for a cloud Android phone. Only canonical identifiers - are accepted. Other backends are deployment-specific; recognized but unavailable - types return DEVICE_TYPE_UNAVAILABLE (422). Retired dedicated*\\** aliases are - rejected with a canonical replacement. + device_type: Device type: android_cloud_phone (cloud Android phone), ios_phone or + device_slot. Any other value is rejected with 422. Not every device type is + available for creation; an unavailable type returns DEVICE_TYPE_UNAVAILABLE + (422). profile_id: Profile ID to use as device spec + template: Optional device template, e.g. onboarding. The device gets the template's + Android version and preinstalled apps and is ready in seconds when a prepared + phone is available; otherwise it boots with the same setup. Country, name and + proxy still come from this request. Cannot be combined with profileId, apps or + androidVersion. Omit it to create from the request alone. + extra_headers: Send extra headers extra_query: Add additional query parameters to the request @@ -1221,6 +1240,7 @@ async def create( "query_country": query_country, "device_type": device_type, "profile_id": profile_id, + "template": template, }, device_create_params.DeviceCreateParams, ), @@ -1296,15 +1316,7 @@ async def list( ] ] | Omit = omit, - type: Literal[ - "android_cloud_phone", - "android_physical_phone", - "ios_stealth_phone", - "android_emulator", - "ios_simulator", - "device_slot", - ] - | Omit = omit, + type: Literal["android_cloud_phone", "ios_phone", "device_slot"] | Omit = omit, # 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, @@ -1329,8 +1341,7 @@ async def list( mine: When true, only return devices created by the authenticated caller. - platform: Filter by the device's platform as served in the platform field (runtime, - announced, else type-derived). + platform: Filter by the device's platform as served in the platform field. search: Case-insensitive search: matches devices whose name contains the term or whose ID starts with it. Combined with all other filters. @@ -1339,8 +1350,7 @@ async def list( to every state except terminated and unknown, so stopped and maintenance devices are listed; pass state=terminated or state=unknown to see those. - type: Canonical device type. Retired dedicated\\__\\** aliases are no longer accepted. - Availability depends on the deployment. + type: Filter by device type. extra_headers: Send extra headers @@ -1463,7 +1473,10 @@ async def reboot( """Triggers a reboot of the device. The device transitions through its reboot - lifecycle and becomes ready again once the restart completes. + lifecycle and becomes ready again once the restart completes. Only devices whose + capabilities report `reboot=true` can be rebooted. Personal (BYOD) devices + cannot be rebooted remotely: the request is refused with 400 + `DEVICE_TOOL_UNSUPPORTED` and nothing happens on the device. Args: extra_headers: Send extra headers @@ -1496,6 +1509,7 @@ async def reset( device_id: str, *, mode: Literal["full", "identity"] | Omit = omit, + preserve: Optional[List[Literal["proxy", "location", "locale", "timezone"]]] | Omit = omit, # 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, @@ -1506,16 +1520,13 @@ async def reset( ) -> None: """Resets the device. - The optional body `mode` selects what is erased: `full` is a - factory reset that erases installed apps, accounts and storage and gives the - device a new identity; `identity` gives the device a new fingerprint and keeps - its apps and data. When `mode` is omitted the reset is `full`, or `identity` on - devices whose capabilities report `factoryReset=false`. A mode the device does - not support (see `factoryReset` / `identityReset` in the device capabilities) is - refused with 400 `DEVICE_TOOL_UNSUPPORTED`; legacy devices accept an explicit - mode only when it is the one their capabilities advertise, and always accept a - reset without a mode. The device transitions through its reset lifecycle before - becoming ready again. + `mode` selects what is erased: `full` (factory reset: apps, + accounts, storage, new identity) or `identity` (new fingerprint, apps and data + kept). Without `mode` the reset is `full`, or `identity` on devices with + `factoryReset=false`. A mode or `preserve` value the device does not support is + refused with 400 `DEVICE_TOOL_UNSUPPORTED`. `preserve` restores the latest + proxy, location, locale or timezone set through the API after the reset; omitted + or empty preserves nothing. The device becomes ready again after the reset. Args: mode: What to erase. full: factory reset — erases the user data (apps, accounts, @@ -1523,6 +1534,9 @@ async def reset( apps and data are kept. When omitted: full, or identity on devices whose capabilities report factoryReset=false. + preserve: Device configuration to restore after the reset: the latest value set through + the API. Omitted, null or empty preserves nothing. + extra_headers: Send extra headers extra_query: Add additional query parameters to the request @@ -1538,7 +1552,13 @@ async def reset( extra_headers = {"Accept": "*/*", **(extra_headers or {})} return await self._post( path_template("/devices/{device_id}/reset", device_id=device_id), - body=await async_maybe_transform({"mode": mode}, device_reset_params.DeviceResetParams), + body=await async_maybe_transform( + { + "mode": mode, + "preserve": preserve, + }, + device_reset_params.DeviceResetParams, + ), options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, @@ -1562,9 +1582,9 @@ async def resume( idempotency_key: str | None = None, ) -> None: """ - Wakes a parked device: backend readiness and any required capacity are - preflighted, the same device starts running again, and per-minute billing - resumes. On a device that is not parked this is a no-op ready transition. + Wakes a parked device: it first checks that the device can run again, then the + same device starts and per-minute billing resumes. On a device that is not + parked, the request does nothing. Args: extra_headers: Send extra headers @@ -1781,9 +1801,13 @@ async def terminate( ) -> None: """Terminates the device and releases its resources. - The optional `terminateAt` and - `previousDeviceId` body fields are not available to API-key callers; requests - that set them are rejected with 401. + For a personal (BYOD) device + the owner (API key or user) can instead remove the phone from the account so + anyone can pair it again; the phone must be disconnected first, otherwise the + request is rejected with 409 BYOD_DEVICE_CONNECTED. Other subscription-billed + devices cannot be terminated with this request; it is rejected with 401. The + `terminateAt` and `previousDeviceId` body fields are reserved for internal use; + requests that set them are rejected with 401. Args: extra_headers: Send extra headers diff --git a/src/mobilerun_sdk/resources/devices/keyboard.py b/src/mobilerun_sdk/resources/devices/keyboard.py index 97181e59..d8f727c8 100644 --- a/src/mobilerun_sdk/resources/devices/keyboard.py +++ b/src/mobilerun_sdk/resources/devices/keyboard.py @@ -171,7 +171,7 @@ def write( operation; committed additionally waits for the focused UI state to contain the complete text or become quiescent. - error_rate: Per-character mistake rate for humantouch typing. -1 uses server default. + error_rate: Per-character mistake rate for humanized typing. -1 uses server default. humanize: Request human-like input where supported by the device. Defaults to false. @@ -372,7 +372,7 @@ async def write( operation; committed additionally waits for the focused UI state to contain the complete text or become quiescent. - error_rate: Per-character mistake rate for humantouch typing. -1 uses server default. + error_rate: Per-character mistake rate for humanized typing. -1 uses server default. humanize: Request human-like input where supported by the device. Defaults to false. diff --git a/src/mobilerun_sdk/resources/devices/language.py b/src/mobilerun_sdk/resources/devices/language.py index 5b49b5e4..0b69e4cd 100644 --- a/src/mobilerun_sdk/resources/devices/language.py +++ b/src/mobilerun_sdk/resources/devices/language.py @@ -99,15 +99,17 @@ def set( """Sets the device language/locale to the BCP-47 locale in the request body. An - optional restart flag applies the change immediately by restarting the zygote - instead of waiting for the next reboot. + optional restart flag applies the change immediately by restarting the Android + system framework (open apps are closed) instead of waiting for the next reboot; + some devices ignore it. Args: locale: BCP-47 locale: a 2–3 letter language tag, optionally followed by a 4-letter script and/or a 2-letter region (e.g. en-US, de-DE, ja-JP, zh-Hans-CN). - restart: Restart zygote so the locale change takes full effect immediately. Without it, - the locale is written but won't fully apply until the next reboot. + restart: Restart the Android system framework so the locale change takes full effect + immediately; open apps are closed. Without it, the change may not fully apply + until the next reboot. Some devices ignore this flag. extra_headers: Send extra headers @@ -226,15 +228,17 @@ async def set( """Sets the device language/locale to the BCP-47 locale in the request body. An - optional restart flag applies the change immediately by restarting the zygote - instead of waiting for the next reboot. + optional restart flag applies the change immediately by restarting the Android + system framework (open apps are closed) instead of waiting for the next reboot; + some devices ignore it. Args: locale: BCP-47 locale: a 2–3 letter language tag, optionally followed by a 4-letter script and/or a 2-letter region (e.g. en-US, de-DE, ja-JP, zh-Hans-CN). - restart: Restart zygote so the locale change takes full effect immediately. Without it, - the locale is written but won't fully apply until the next reboot. + restart: Restart the Android system framework so the locale change takes full effect + immediately; open apps are closed. Without it, the change may not fully apply + until the next reboot. Some devices ignore this flag. extra_headers: Send extra headers diff --git a/src/mobilerun_sdk/resources/mailboxes/messages.py b/src/mobilerun_sdk/resources/mailboxes/messages.py index 2e7c54cd..e0cfd861 100644 --- a/src/mobilerun_sdk/resources/mailboxes/messages.py +++ b/src/mobilerun_sdk/resources/mailboxes/messages.py @@ -19,7 +19,7 @@ async_to_streamed_response_wrapper, ) from ..._base_client import make_request_options -from ...types.mailboxes import message_list_params +from ...types.mailboxes import message_list_params, message_retrieve_params from ...types.mailboxes.message_list_response import MessageListResponse from ...types.mailboxes.message_retrieve_response import MessageRetrieveResponse @@ -51,6 +51,7 @@ def retrieve( message_id: str, *, mailbox_id: str, + include_html: Literal["true", "false"] | Omit = omit, # 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, @@ -62,6 +63,8 @@ def retrieve( Get a mailbox message Args: + include_html: Return the raw HTML part as htmlBody (untrusted; render isolated). + extra_headers: Send extra headers extra_query: Add additional query parameters to the request @@ -79,7 +82,11 @@ def retrieve( "/mailboxes/{mailbox_id}/messages/{message_id}", mailbox_id=mailbox_id, message_id=message_id ), options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=maybe_transform({"include_html": include_html}, message_retrieve_params.MessageRetrieveParams), ), cast_to=MessageRetrieveResponse, ) @@ -162,6 +169,7 @@ async def retrieve( message_id: str, *, mailbox_id: str, + include_html: Literal["true", "false"] | Omit = omit, # 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, @@ -173,6 +181,8 @@ async def retrieve( Get a mailbox message Args: + include_html: Return the raw HTML part as htmlBody (untrusted; render isolated). + extra_headers: Send extra headers extra_query: Add additional query parameters to the request @@ -190,7 +200,13 @@ async def retrieve( "/mailboxes/{mailbox_id}/messages/{message_id}", mailbox_id=mailbox_id, message_id=message_id ), options=make_request_options( - extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=await async_maybe_transform( + {"include_html": include_html}, message_retrieve_params.MessageRetrieveParams + ), ), cast_to=MessageRetrieveResponse, ) diff --git a/src/mobilerun_sdk/resources/messages/messages.py b/src/mobilerun_sdk/resources/messages/messages.py index 3d78e80a..944c2e57 100644 --- a/src/mobilerun_sdk/resources/messages/messages.py +++ b/src/mobilerun_sdk/resources/messages/messages.py @@ -118,6 +118,9 @@ def list( status, and conversation. Args: + status: Filter by message status. `delivered` and `sent_unconfirmed` are kept for + compatibility and are not emitted on current lines. + extra_headers: Send extra headers extra_query: Add additional query parameters to the request @@ -237,6 +240,9 @@ async def list( status, and conversation. Args: + status: Filter by message status. `delivered` and `sent_unconfirmed` are kept for + compatibility and are not emitted on current lines. + extra_headers: Send extra headers extra_query: Add additional query parameters to the request diff --git a/src/mobilerun_sdk/resources/numbers/messages.py b/src/mobilerun_sdk/resources/numbers/messages.py index 9d75430d..efcfde0a 100644 --- a/src/mobilerun_sdk/resources/numbers/messages.py +++ b/src/mobilerun_sdk/resources/numbers/messages.py @@ -133,7 +133,9 @@ def send( number cannot send to are rejected with 422 unsupported_destination, non-numbers with 422 invalid_recipient. - delivery_report: Request a delivery report. Defaults to false. + delivery_report: Deprecated: best effort and ignored on most lines. Hosted SIM numbers return no + carrier delivery report, so their messages end at `sent` and no + `sms.send.delivered` event follows. Defaults to false. extra_headers: Send extra headers @@ -275,7 +277,9 @@ async def send( number cannot send to are rejected with 422 unsupported_destination, non-numbers with 422 invalid_recipient. - delivery_report: Request a delivery report. Defaults to false. + delivery_report: Deprecated: best effort and ignored on most lines. Hosted SIM numbers return no + carrier delivery report, so their messages end at `sent` and no + `sms.send.delivered` event follows. Defaults to false. extra_headers: Send extra headers diff --git a/src/mobilerun_sdk/resources/tasks/tasks.py b/src/mobilerun_sdk/resources/tasks/tasks.py index 920f9755..4756e5be 100644 --- a/src/mobilerun_sdk/resources/tasks/tasks.py +++ b/src/mobilerun_sdk/resources/tasks/tasks.py @@ -326,7 +326,8 @@ def run( stealth field; both must agree when supplied together. llm_model: The LLM model identifier to use for the task (e.g. - 'mobilerun/mobile-agent-fast') + 'mobilerun/mobile-agent-fast'). When omitted with reasoning=false, the fast-mode + default model is used. recording_enabled: Record device video for the whole task and persist a retrievable reference @@ -434,7 +435,8 @@ def run_streamed( stealth field; both must agree when supplied together. llm_model: The LLM model identifier to use for the task (e.g. - 'mobilerun/mobile-agent-fast') + 'mobilerun/mobile-agent-fast'). When omitted with reasoning=false, the fast-mode + default model is used. recording_enabled: Record device video for the whole task and persist a retrievable reference @@ -864,7 +866,8 @@ async def run( stealth field; both must agree when supplied together. llm_model: The LLM model identifier to use for the task (e.g. - 'mobilerun/mobile-agent-fast') + 'mobilerun/mobile-agent-fast'). When omitted with reasoning=false, the fast-mode + default model is used. recording_enabled: Record device video for the whole task and persist a retrievable reference @@ -972,7 +975,8 @@ async def run_streamed( stealth field; both must agree when supplied together. llm_model: The LLM model identifier to use for the task (e.g. - 'mobilerun/mobile-agent-fast') + 'mobilerun/mobile-agent-fast'). When omitted with reasoning=false, the fast-mode + default model is used. recording_enabled: Record device video for the whole task and persist a retrievable reference diff --git a/src/mobilerun_sdk/types/assistant/conversation_send_params.py b/src/mobilerun_sdk/types/assistant/conversation_send_params.py index 60413764..dabc151c 100644 --- a/src/mobilerun_sdk/types/assistant/conversation_send_params.py +++ b/src/mobilerun_sdk/types/assistant/conversation_send_params.py @@ -15,3 +15,5 @@ class ConversationSendParams(TypedDict, total=False): session_id: Required[Annotated[str, PropertyInfo(alias="sessionId")]] agent: str + + model: str diff --git a/src/mobilerun_sdk/types/connect/__init__.py b/src/mobilerun_sdk/types/connect/__init__.py index 1c5d9034..e38463b1 100644 --- a/src/mobilerun_sdk/types/connect/__init__.py +++ b/src/mobilerun_sdk/types/connect/__init__.py @@ -18,6 +18,7 @@ from .country_list_response import CountryListResponse as CountryListResponse from .proxy_update_response import ProxyUpdateResponse as ProxyUpdateResponse from .user_retrieve_response import UserRetrieveResponse as UserRetrieveResponse +from .proxy_checkout_response import ProxyCheckoutResponse as ProxyCheckoutResponse from .proxy_retrieve_response import ProxyRetrieveResponse as ProxyRetrieveResponse from .user_list_connections_params import UserListConnectionsParams as UserListConnectionsParams from .proxy_ensure_healthy_response import ProxyEnsureHealthyResponse as ProxyEnsureHealthyResponse diff --git a/src/mobilerun_sdk/types/connect/proxy_checkout_response.py b/src/mobilerun_sdk/types/connect/proxy_checkout_response.py new file mode 100644 index 00000000..fc8d4632 --- /dev/null +++ b/src/mobilerun_sdk/types/connect/proxy_checkout_response.py @@ -0,0 +1,26 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import Optional +from typing_extensions import Literal + +from pydantic import Field as FieldInfo + +from ..._models import BaseModel + +__all__ = ["ProxyCheckoutResponse"] + + +class ProxyCheckoutResponse(BaseModel): + status: Literal["checking", "pending_payment", "provisioning", "active", "cancelling", "ended", "error"] + """Lifecycle of a proxy. + + A freshly created proxy is `checking` while its billing identity is being + resolved — clients should poll until a `paymentUrl` or a later status appears — + then `provisioning` — or `pending_payment` until the customer completes checkout + — and becomes `active` once its upstream is assigned. `cancelling` retains full + access through the paid period; when the subscription expires the proxy is + `ended`. `error` marks a failed provisioning attempt. + """ + + payment_url: Optional[str] = FieldInfo(alias="paymentUrl", default=None) + """Payable checkout URL; omitted after payment.""" diff --git a/src/mobilerun_sdk/types/credential_list_response.py b/src/mobilerun_sdk/types/credential_list_response.py index 38da9557..0f8d2656 100644 --- a/src/mobilerun_sdk/types/credential_list_response.py +++ b/src/mobilerun_sdk/types/credential_list_response.py @@ -8,7 +8,7 @@ from .._models import BaseModel from .shared.pagination import Pagination -__all__ = ["CredentialListResponse", "Item", "ItemField"] +__all__ = ["CredentialListResponse", "Item", "ItemField", "ItemLink", "ItemLinkFieldMap"] class ItemField(BaseModel): @@ -19,6 +19,28 @@ class ItemField(BaseModel): value: str +class ItemLinkFieldMap(BaseModel): + field_id: str = FieldInfo(alias="fieldId") + + field_type: Literal[ + "email", "username", "password", "api_token", "phone_number", "two_factor_secret", "backup_codes" + ] = FieldInfo(alias="fieldType") + + +class ItemLink(BaseModel): + field_map: List[ItemLinkFieldMap] = FieldInfo(alias="fieldMap") + + item_id: str = FieldInfo(alias="itemId") + + item_title: str = FieldInfo(alias="itemTitle") + + provider: Literal["onepassword"] + + vault_id: str = FieldInfo(alias="vaultId") + + vault_name: str = FieldInfo(alias="vaultName") + + class Item(BaseModel): created_by: Optional[str] = FieldInfo(alias="createdBy", default=None) @@ -38,6 +60,10 @@ class Item(BaseModel): Null for credentials created before rollout. """ + link: Optional[ItemLink] = None + + source: Optional[Literal["mobilerun", "onepassword"]] = None + class CredentialListResponse(BaseModel): items: List[Item] diff --git a/src/mobilerun_sdk/types/credentials/__init__.py b/src/mobilerun_sdk/types/credentials/__init__.py index 9d64da9b..f91e9e4f 100644 --- a/src/mobilerun_sdk/types/credentials/__init__.py +++ b/src/mobilerun_sdk/types/credentials/__init__.py @@ -6,3 +6,7 @@ from .package_list_response import PackageListResponse as PackageListResponse from .package_create_response import PackageCreateResponse as PackageCreateResponse from .package_list_all_response import PackageListAllResponse as PackageListAllResponse +from .onepassword_connect_params import OnepasswordConnectParams as OnepasswordConnectParams +from .onepassword_connect_response import OnepasswordConnectResponse as OnepasswordConnectResponse +from .onepassword_retrieve_response import OnepasswordRetrieveResponse as OnepasswordRetrieveResponse +from .onepassword_disconnect_response import OnepasswordDisconnectResponse as OnepasswordDisconnectResponse diff --git a/src/mobilerun_sdk/types/credentials/onepassword/__init__.py b/src/mobilerun_sdk/types/credentials/onepassword/__init__.py new file mode 100644 index 00000000..f8ee8b14 --- /dev/null +++ b/src/mobilerun_sdk/types/credentials/onepassword/__init__.py @@ -0,0 +1,3 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations diff --git a/src/mobilerun_sdk/types/credentials/onepassword/vaults/__init__.py b/src/mobilerun_sdk/types/credentials/onepassword/vaults/__init__.py new file mode 100644 index 00000000..93502d4f --- /dev/null +++ b/src/mobilerun_sdk/types/credentials/onepassword/vaults/__init__.py @@ -0,0 +1,5 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from .item_list_response import ItemListResponse as ItemListResponse diff --git a/src/mobilerun_sdk/types/credentials/onepassword/vaults/item_list_response.py b/src/mobilerun_sdk/types/credentials/onepassword/vaults/item_list_response.py new file mode 100644 index 00000000..6f79c78e --- /dev/null +++ b/src/mobilerun_sdk/types/credentials/onepassword/vaults/item_list_response.py @@ -0,0 +1,27 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List + +from ....._models import BaseModel + +__all__ = ["ItemListResponse", "Data", "DataWebsite"] + + +class DataWebsite(BaseModel): + label: str + + url: str + + +class Data(BaseModel): + id: str + + category: str + + title: str + + websites: List[DataWebsite] + + +class ItemListResponse(BaseModel): + data: List[Data] diff --git a/src/mobilerun_sdk/types/credentials/onepassword/vaults/items/__init__.py b/src/mobilerun_sdk/types/credentials/onepassword/vaults/items/__init__.py new file mode 100644 index 00000000..89fcdf96 --- /dev/null +++ b/src/mobilerun_sdk/types/credentials/onepassword/vaults/items/__init__.py @@ -0,0 +1,5 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from .field_list_response import FieldListResponse as FieldListResponse diff --git a/src/mobilerun_sdk/types/credentials/onepassword/vaults/items/field_list_response.py b/src/mobilerun_sdk/types/credentials/onepassword/vaults/items/field_list_response.py new file mode 100644 index 00000000..9ab6c749 --- /dev/null +++ b/src/mobilerun_sdk/types/credentials/onepassword/vaults/items/field_list_response.py @@ -0,0 +1,23 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List, Optional + +from pydantic import Field as FieldInfo + +from ......_models import BaseModel + +__all__ = ["FieldListResponse", "Data"] + + +class Data(BaseModel): + id: str + + field_type: str = FieldInfo(alias="fieldType") + + title: str + + section_id: Optional[str] = FieldInfo(alias="sectionId", default=None) + + +class FieldListResponse(BaseModel): + data: List[Data] diff --git a/src/mobilerun_sdk/types/credentials/onepassword_connect_params.py b/src/mobilerun_sdk/types/credentials/onepassword_connect_params.py new file mode 100644 index 00000000..a2a1edb4 --- /dev/null +++ b/src/mobilerun_sdk/types/credentials/onepassword_connect_params.py @@ -0,0 +1,13 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing_extensions import Required, Annotated, TypedDict + +from ..._utils import PropertyInfo + +__all__ = ["OnepasswordConnectParams"] + + +class OnepasswordConnectParams(TypedDict, total=False): + service_account_token: Required[Annotated[str, PropertyInfo(alias="serviceAccountToken")]] diff --git a/src/mobilerun_sdk/types/credentials/onepassword_connect_response.py b/src/mobilerun_sdk/types/credentials/onepassword_connect_response.py new file mode 100644 index 00000000..185aa2b9 --- /dev/null +++ b/src/mobilerun_sdk/types/credentials/onepassword_connect_response.py @@ -0,0 +1,29 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List, Optional + +from pydantic import Field as FieldInfo + +from ..._models import BaseModel + +__all__ = ["OnepasswordConnectResponse", "Data", "DataVault"] + + +class DataVault(BaseModel): + id: str + + title: str + + +class Data(BaseModel): + connected: bool + + connected_at: Optional[str] = FieldInfo(alias="connectedAt", default=None) + + connected_by: Optional[str] = FieldInfo(alias="connectedBy", default=None) + + vaults: Optional[List[DataVault]] = None + + +class OnepasswordConnectResponse(BaseModel): + data: Data diff --git a/src/mobilerun_sdk/types/credentials/onepassword_disconnect_response.py b/src/mobilerun_sdk/types/credentials/onepassword_disconnect_response.py new file mode 100644 index 00000000..836189d5 --- /dev/null +++ b/src/mobilerun_sdk/types/credentials/onepassword_disconnect_response.py @@ -0,0 +1,9 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from ..._models import BaseModel + +__all__ = ["OnepasswordDisconnectResponse"] + + +class OnepasswordDisconnectResponse(BaseModel): + message: str diff --git a/src/mobilerun_sdk/types/credentials/onepassword_retrieve_response.py b/src/mobilerun_sdk/types/credentials/onepassword_retrieve_response.py new file mode 100644 index 00000000..927e7813 --- /dev/null +++ b/src/mobilerun_sdk/types/credentials/onepassword_retrieve_response.py @@ -0,0 +1,29 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import List, Optional + +from pydantic import Field as FieldInfo + +from ..._models import BaseModel + +__all__ = ["OnepasswordRetrieveResponse", "Data", "DataVault"] + + +class DataVault(BaseModel): + id: str + + title: str + + +class Data(BaseModel): + connected: bool + + connected_at: Optional[str] = FieldInfo(alias="connectedAt", default=None) + + connected_by: Optional[str] = FieldInfo(alias="connectedBy", default=None) + + vaults: Optional[List[DataVault]] = None + + +class OnepasswordRetrieveResponse(BaseModel): + data: Data diff --git a/src/mobilerun_sdk/types/credentials/package_list_response.py b/src/mobilerun_sdk/types/credentials/package_list_response.py index 092a1df9..c4d78458 100644 --- a/src/mobilerun_sdk/types/credentials/package_list_response.py +++ b/src/mobilerun_sdk/types/credentials/package_list_response.py @@ -7,7 +7,7 @@ from ..._models import BaseModel -__all__ = ["PackageListResponse", "Data", "DataField"] +__all__ = ["PackageListResponse", "Data", "DataField", "DataLink", "DataLinkFieldMap"] class DataField(BaseModel): @@ -18,6 +18,28 @@ class DataField(BaseModel): value: str +class DataLinkFieldMap(BaseModel): + field_id: str = FieldInfo(alias="fieldId") + + field_type: Literal[ + "email", "username", "password", "api_token", "phone_number", "two_factor_secret", "backup_codes" + ] = FieldInfo(alias="fieldType") + + +class DataLink(BaseModel): + field_map: List[DataLinkFieldMap] = FieldInfo(alias="fieldMap") + + item_id: str = FieldInfo(alias="itemId") + + item_title: str = FieldInfo(alias="itemTitle") + + provider: Literal["onepassword"] + + vault_id: str = FieldInfo(alias="vaultId") + + vault_name: str = FieldInfo(alias="vaultName") + + class Data(BaseModel): created_by: Optional[str] = FieldInfo(alias="createdBy", default=None) @@ -37,6 +59,10 @@ class Data(BaseModel): Null for credentials created before rollout. """ + link: Optional[DataLink] = None + + source: Optional[Literal["mobilerun", "onepassword"]] = None + class PackageListResponse(BaseModel): data: List[Data] diff --git a/src/mobilerun_sdk/types/credentials/packages/__init__.py b/src/mobilerun_sdk/types/credentials/packages/__init__.py index e5fc9088..c88be64d 100644 --- a/src/mobilerun_sdk/types/credentials/packages/__init__.py +++ b/src/mobilerun_sdk/types/credentials/packages/__init__.py @@ -2,7 +2,8 @@ from __future__ import annotations +from .link_create_params import LinkCreateParams as LinkCreateParams +from .link_create_response import LinkCreateResponse as LinkCreateResponse from .credential_create_params import CredentialCreateParams as CredentialCreateParams from .credential_create_response import CredentialCreateResponse as CredentialCreateResponse from .credential_delete_response import CredentialDeleteResponse as CredentialDeleteResponse -from .credential_retrieve_response import CredentialRetrieveResponse as CredentialRetrieveResponse diff --git a/src/mobilerun_sdk/types/credentials/packages/credential_create_response.py b/src/mobilerun_sdk/types/credentials/packages/credential_create_response.py index 8cce5a94..6dd3df0a 100644 --- a/src/mobilerun_sdk/types/credentials/packages/credential_create_response.py +++ b/src/mobilerun_sdk/types/credentials/packages/credential_create_response.py @@ -7,7 +7,7 @@ from ...._models import BaseModel -__all__ = ["CredentialCreateResponse", "Data", "DataField"] +__all__ = ["CredentialCreateResponse", "Data", "DataField", "DataLink", "DataLinkFieldMap"] class DataField(BaseModel): @@ -18,6 +18,28 @@ class DataField(BaseModel): value: str +class DataLinkFieldMap(BaseModel): + field_id: str = FieldInfo(alias="fieldId") + + field_type: Literal[ + "email", "username", "password", "api_token", "phone_number", "two_factor_secret", "backup_codes" + ] = FieldInfo(alias="fieldType") + + +class DataLink(BaseModel): + field_map: List[DataLinkFieldMap] = FieldInfo(alias="fieldMap") + + item_id: str = FieldInfo(alias="itemId") + + item_title: str = FieldInfo(alias="itemTitle") + + provider: Literal["onepassword"] + + vault_id: str = FieldInfo(alias="vaultId") + + vault_name: str = FieldInfo(alias="vaultName") + + class Data(BaseModel): created_by: Optional[str] = FieldInfo(alias="createdBy", default=None) @@ -37,6 +59,10 @@ class Data(BaseModel): Null for credentials created before rollout. """ + link: Optional[DataLink] = None + + source: Optional[Literal["mobilerun", "onepassword"]] = None + class CredentialCreateResponse(BaseModel): data: Data diff --git a/src/mobilerun_sdk/types/credentials/packages/credential_delete_response.py b/src/mobilerun_sdk/types/credentials/packages/credential_delete_response.py index f5528ed9..16825302 100644 --- a/src/mobilerun_sdk/types/credentials/packages/credential_delete_response.py +++ b/src/mobilerun_sdk/types/credentials/packages/credential_delete_response.py @@ -7,7 +7,7 @@ from ...._models import BaseModel -__all__ = ["CredentialDeleteResponse", "Data", "DataField"] +__all__ = ["CredentialDeleteResponse", "Data", "DataField", "DataLink", "DataLinkFieldMap"] class DataField(BaseModel): @@ -18,6 +18,28 @@ class DataField(BaseModel): value: str +class DataLinkFieldMap(BaseModel): + field_id: str = FieldInfo(alias="fieldId") + + field_type: Literal[ + "email", "username", "password", "api_token", "phone_number", "two_factor_secret", "backup_codes" + ] = FieldInfo(alias="fieldType") + + +class DataLink(BaseModel): + field_map: List[DataLinkFieldMap] = FieldInfo(alias="fieldMap") + + item_id: str = FieldInfo(alias="itemId") + + item_title: str = FieldInfo(alias="itemTitle") + + provider: Literal["onepassword"] + + vault_id: str = FieldInfo(alias="vaultId") + + vault_name: str = FieldInfo(alias="vaultName") + + class Data(BaseModel): created_by: Optional[str] = FieldInfo(alias="createdBy", default=None) @@ -37,6 +59,10 @@ class Data(BaseModel): Null for credentials created before rollout. """ + link: Optional[DataLink] = None + + source: Optional[Literal["mobilerun", "onepassword"]] = None + class CredentialDeleteResponse(BaseModel): data: Data diff --git a/src/mobilerun_sdk/types/credentials/packages/credentials/field_create_response.py b/src/mobilerun_sdk/types/credentials/packages/credentials/field_create_response.py index c3e3a102..32c99dce 100644 --- a/src/mobilerun_sdk/types/credentials/packages/credentials/field_create_response.py +++ b/src/mobilerun_sdk/types/credentials/packages/credentials/field_create_response.py @@ -7,7 +7,7 @@ from ....._models import BaseModel -__all__ = ["FieldCreateResponse", "Data", "DataField"] +__all__ = ["FieldCreateResponse", "Data", "DataField", "DataLink", "DataLinkFieldMap"] class DataField(BaseModel): @@ -18,6 +18,28 @@ class DataField(BaseModel): value: str +class DataLinkFieldMap(BaseModel): + field_id: str = FieldInfo(alias="fieldId") + + field_type: Literal[ + "email", "username", "password", "api_token", "phone_number", "two_factor_secret", "backup_codes" + ] = FieldInfo(alias="fieldType") + + +class DataLink(BaseModel): + field_map: List[DataLinkFieldMap] = FieldInfo(alias="fieldMap") + + item_id: str = FieldInfo(alias="itemId") + + item_title: str = FieldInfo(alias="itemTitle") + + provider: Literal["onepassword"] + + vault_id: str = FieldInfo(alias="vaultId") + + vault_name: str = FieldInfo(alias="vaultName") + + class Data(BaseModel): created_by: Optional[str] = FieldInfo(alias="createdBy", default=None) @@ -37,6 +59,10 @@ class Data(BaseModel): Null for credentials created before rollout. """ + link: Optional[DataLink] = None + + source: Optional[Literal["mobilerun", "onepassword"]] = None + class FieldCreateResponse(BaseModel): data: Data diff --git a/src/mobilerun_sdk/types/credentials/packages/credentials/field_delete_response.py b/src/mobilerun_sdk/types/credentials/packages/credentials/field_delete_response.py index 25d64be0..5cbb4ebb 100644 --- a/src/mobilerun_sdk/types/credentials/packages/credentials/field_delete_response.py +++ b/src/mobilerun_sdk/types/credentials/packages/credentials/field_delete_response.py @@ -7,7 +7,7 @@ from ....._models import BaseModel -__all__ = ["FieldDeleteResponse", "Data", "DataField"] +__all__ = ["FieldDeleteResponse", "Data", "DataField", "DataLink", "DataLinkFieldMap"] class DataField(BaseModel): @@ -18,6 +18,28 @@ class DataField(BaseModel): value: str +class DataLinkFieldMap(BaseModel): + field_id: str = FieldInfo(alias="fieldId") + + field_type: Literal[ + "email", "username", "password", "api_token", "phone_number", "two_factor_secret", "backup_codes" + ] = FieldInfo(alias="fieldType") + + +class DataLink(BaseModel): + field_map: List[DataLinkFieldMap] = FieldInfo(alias="fieldMap") + + item_id: str = FieldInfo(alias="itemId") + + item_title: str = FieldInfo(alias="itemTitle") + + provider: Literal["onepassword"] + + vault_id: str = FieldInfo(alias="vaultId") + + vault_name: str = FieldInfo(alias="vaultName") + + class Data(BaseModel): created_by: Optional[str] = FieldInfo(alias="createdBy", default=None) @@ -37,6 +59,10 @@ class Data(BaseModel): Null for credentials created before rollout. """ + link: Optional[DataLink] = None + + source: Optional[Literal["mobilerun", "onepassword"]] = None + class FieldDeleteResponse(BaseModel): data: Data diff --git a/src/mobilerun_sdk/types/credentials/packages/credentials/field_update_response.py b/src/mobilerun_sdk/types/credentials/packages/credentials/field_update_response.py index 4a37ce71..d9fec0da 100644 --- a/src/mobilerun_sdk/types/credentials/packages/credentials/field_update_response.py +++ b/src/mobilerun_sdk/types/credentials/packages/credentials/field_update_response.py @@ -7,7 +7,7 @@ from ....._models import BaseModel -__all__ = ["FieldUpdateResponse", "Data", "DataField"] +__all__ = ["FieldUpdateResponse", "Data", "DataField", "DataLink", "DataLinkFieldMap"] class DataField(BaseModel): @@ -18,6 +18,28 @@ class DataField(BaseModel): value: str +class DataLinkFieldMap(BaseModel): + field_id: str = FieldInfo(alias="fieldId") + + field_type: Literal[ + "email", "username", "password", "api_token", "phone_number", "two_factor_secret", "backup_codes" + ] = FieldInfo(alias="fieldType") + + +class DataLink(BaseModel): + field_map: List[DataLinkFieldMap] = FieldInfo(alias="fieldMap") + + item_id: str = FieldInfo(alias="itemId") + + item_title: str = FieldInfo(alias="itemTitle") + + provider: Literal["onepassword"] + + vault_id: str = FieldInfo(alias="vaultId") + + vault_name: str = FieldInfo(alias="vaultName") + + class Data(BaseModel): created_by: Optional[str] = FieldInfo(alias="createdBy", default=None) @@ -37,6 +59,10 @@ class Data(BaseModel): Null for credentials created before rollout. """ + link: Optional[DataLink] = None + + source: Optional[Literal["mobilerun", "onepassword"]] = None + class FieldUpdateResponse(BaseModel): data: Data diff --git a/src/mobilerun_sdk/types/credentials/packages/link_create_params.py b/src/mobilerun_sdk/types/credentials/packages/link_create_params.py new file mode 100644 index 00000000..3c0d43b6 --- /dev/null +++ b/src/mobilerun_sdk/types/credentials/packages/link_create_params.py @@ -0,0 +1,31 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Iterable +from typing_extensions import Literal, Required, Annotated, TypedDict + +from ...._utils import PropertyInfo + +__all__ = ["LinkCreateParams", "FieldMap"] + + +class LinkCreateParams(TypedDict, total=False): + credential_name: Required[Annotated[str, PropertyInfo(alias="credentialName")]] + + field_map: Required[Annotated[Iterable[FieldMap], PropertyInfo(alias="fieldMap")]] + + item_id: Required[Annotated[str, PropertyInfo(alias="itemId")]] + + vault_id: Required[Annotated[str, PropertyInfo(alias="vaultId")]] + + +class FieldMap(TypedDict, total=False): + field_id: Required[Annotated[str, PropertyInfo(alias="fieldId")]] + + field_type: Required[ + Annotated[ + Literal["email", "username", "password", "api_token", "phone_number", "two_factor_secret", "backup_codes"], + PropertyInfo(alias="fieldType"), + ] + ] diff --git a/src/mobilerun_sdk/types/credentials/packages/credential_retrieve_response.py b/src/mobilerun_sdk/types/credentials/packages/link_create_response.py similarity index 55% rename from src/mobilerun_sdk/types/credentials/packages/credential_retrieve_response.py rename to src/mobilerun_sdk/types/credentials/packages/link_create_response.py index 11cc259b..74039528 100644 --- a/src/mobilerun_sdk/types/credentials/packages/credential_retrieve_response.py +++ b/src/mobilerun_sdk/types/credentials/packages/link_create_response.py @@ -7,7 +7,7 @@ from ...._models import BaseModel -__all__ = ["CredentialRetrieveResponse", "Data", "DataField"] +__all__ = ["LinkCreateResponse", "Data", "DataField", "DataLink", "DataLinkFieldMap"] class DataField(BaseModel): @@ -18,6 +18,28 @@ class DataField(BaseModel): value: str +class DataLinkFieldMap(BaseModel): + field_id: str = FieldInfo(alias="fieldId") + + field_type: Literal[ + "email", "username", "password", "api_token", "phone_number", "two_factor_secret", "backup_codes" + ] = FieldInfo(alias="fieldType") + + +class DataLink(BaseModel): + field_map: List[DataLinkFieldMap] = FieldInfo(alias="fieldMap") + + item_id: str = FieldInfo(alias="itemId") + + item_title: str = FieldInfo(alias="itemTitle") + + provider: Literal["onepassword"] + + vault_id: str = FieldInfo(alias="vaultId") + + vault_name: str = FieldInfo(alias="vaultName") + + class Data(BaseModel): created_by: Optional[str] = FieldInfo(alias="createdBy", default=None) @@ -37,6 +59,10 @@ class Data(BaseModel): Null for credentials created before rollout. """ + link: Optional[DataLink] = None + + source: Optional[Literal["mobilerun", "onepassword"]] = None + -class CredentialRetrieveResponse(BaseModel): +class LinkCreateResponse(BaseModel): data: Data diff --git a/src/mobilerun_sdk/types/device_create_params.py b/src/mobilerun_sdk/types/device_create_params.py index c8169523..371d4487 100644 --- a/src/mobilerun_sdk/types/device_create_params.py +++ b/src/mobilerun_sdk/types/device_create_params.py @@ -33,17 +33,27 @@ class DeviceCreateParams(TypedDict, total=False): If omitted the system picks the country with the most availability. """ - device_type: Annotated[str, PropertyInfo(alias="deviceType")] - """Use android_cloud_phone for a cloud Android phone. + device_type: Annotated[Literal["android_cloud_phone", "ios_phone", "device_slot"], PropertyInfo(alias="deviceType")] + """Device type: android_cloud_phone (cloud Android phone), ios_phone or + device_slot. - Only canonical identifiers are accepted. Other backends are deployment-specific; - recognized but unavailable types return DEVICE*TYPE_UNAVAILABLE (422). Retired - dedicated*\\** aliases are rejected with a canonical replacement. + Any other value is rejected with 422. Not every device type is available for + creation; an unavailable type returns DEVICE_TYPE_UNAVAILABLE (422). """ profile_id: Annotated[str, PropertyInfo(alias="profileId")] """Profile ID to use as device spec""" + template: str + """Optional device template, e.g. + + onboarding. The device gets the template's Android version and preinstalled apps + and is ready in seconds when a prepared phone is available; otherwise it boots + with the same setup. Country, name and proxy still come from this request. + Cannot be combined with profileId, apps or androidVersion. Omit it to create + from the request alone. + """ + android_version: Annotated[int, PropertyInfo(alias="androidVersion")] apps: Optional[SequenceNotStr[str]] diff --git a/src/mobilerun_sdk/types/device_fingerprint_response.py b/src/mobilerun_sdk/types/device_fingerprint_response.py index 4f8f410f..acfd3c28 100644 --- a/src/mobilerun_sdk/types/device_fingerprint_response.py +++ b/src/mobilerun_sdk/types/device_fingerprint_response.py @@ -28,8 +28,6 @@ class Model(BaseModel): hardware: Optional[str] = None - image_repository: Optional[str] = FieldInfo(alias="imageRepository", default=None) - manufacturer: Optional[str] = None model: Optional[str] = None diff --git a/src/mobilerun_sdk/types/device_list_params.py b/src/mobilerun_sdk/types/device_list_params.py index 46fbca3b..329debad 100644 --- a/src/mobilerun_sdk/types/device_list_params.py +++ b/src/mobilerun_sdk/types/device_list_params.py @@ -42,10 +42,7 @@ class DeviceListParams(TypedDict, total=False): page_size: Annotated[int, PropertyInfo(alias="pageSize")] platform: Literal["android", "ios"] - """ - Filter by the device's platform as served in the platform field (runtime, - announced, else type-derived). - """ + """Filter by the device's platform as served in the platform field.""" provider_id: Annotated[str, PropertyInfo(alias="providerId")] @@ -78,16 +75,5 @@ class DeviceListParams(TypedDict, total=False): state=terminated or state=unknown to see those. """ - type: Literal[ - "android_cloud_phone", - "android_physical_phone", - "ios_stealth_phone", - "android_emulator", - "ios_simulator", - "device_slot", - ] - """Canonical device type. - - Retired dedicated\\__\\** aliases are no longer accepted. Availability depends on - the deployment. - """ + type: Literal["android_cloud_phone", "ios_phone", "device_slot"] + """Filter by device type.""" diff --git a/src/mobilerun_sdk/types/device_reset_params.py b/src/mobilerun_sdk/types/device_reset_params.py index be1929ec..118c9849 100644 --- a/src/mobilerun_sdk/types/device_reset_params.py +++ b/src/mobilerun_sdk/types/device_reset_params.py @@ -2,6 +2,7 @@ from __future__ import annotations +from typing import List, Optional from typing_extensions import Literal, TypedDict __all__ = ["DeviceResetParams"] @@ -16,3 +17,9 @@ class DeviceResetParams(TypedDict, total=False): kept. When omitted: full, or identity on devices whose capabilities report factoryReset=false. """ + + preserve: Optional[List[Literal["proxy", "location", "locale", "timezone"]]] + """ + Device configuration to restore after the reset: the latest value set through + the API. Omitted, null or empty preserves nothing. + """ diff --git a/src/mobilerun_sdk/types/device_retrieve_capabilities_response.py b/src/mobilerun_sdk/types/device_retrieve_capabilities_response.py index 5f8bea01..d53cf502 100644 --- a/src/mobilerun_sdk/types/device_retrieve_capabilities_response.py +++ b/src/mobilerun_sdk/types/device_retrieve_capabilities_response.py @@ -47,6 +47,8 @@ class Capabilities(BaseModel): proxy: bool + reboot: bool + recording: bool reset: bool diff --git a/src/mobilerun_sdk/types/devices/a11_y_node.py b/src/mobilerun_sdk/types/devices/a11_y_node.py index 2d15e339..f9970f13 100644 --- a/src/mobilerun_sdk/types/devices/a11_y_node.py +++ b/src/mobilerun_sdk/types/devices/a11_y_node.py @@ -56,4 +56,6 @@ class A11YNode(BaseModel): text: str + hint: Optional[str] = None + is_visible_to_user: Optional[bool] = FieldInfo(alias="isVisibleToUser", default=None) diff --git a/src/mobilerun_sdk/types/devices/app_list_installs_response.py b/src/mobilerun_sdk/types/devices/app_list_installs_response.py index ae079f10..c4e3f437 100644 --- a/src/mobilerun_sdk/types/devices/app_list_installs_response.py +++ b/src/mobilerun_sdk/types/devices/app_list_installs_response.py @@ -22,8 +22,8 @@ class Install(BaseModel): status: Literal["running", "succeeded", "failed"] """ - On iOS MDM devices, succeeded means the install command was accepted by the - device's MDM channel, not that the install finished on-device. + On some iOS devices, succeeded means the device accepted the install command; + the install may still be running on the device. """ updated_at: datetime = FieldInfo(alias="updatedAt") diff --git a/src/mobilerun_sdk/types/devices/keyboard_write_params.py b/src/mobilerun_sdk/types/devices/keyboard_write_params.py index 73da457f..7ed38ebf 100644 --- a/src/mobilerun_sdk/types/devices/keyboard_write_params.py +++ b/src/mobilerun_sdk/types/devices/keyboard_write_params.py @@ -23,7 +23,7 @@ class KeyboardWriteParams(TypedDict, total=False): """ error_rate: Annotated[float, PropertyInfo(alias="errorRate")] - """Per-character mistake rate for humantouch typing. -1 uses server default.""" + """Per-character mistake rate for humanized typing. -1 uses server default.""" humanize: bool """Request human-like input where supported by the device. Defaults to false.""" diff --git a/src/mobilerun_sdk/types/devices/language_set_params.py b/src/mobilerun_sdk/types/devices/language_set_params.py index 1cfb6436..e01e71d3 100644 --- a/src/mobilerun_sdk/types/devices/language_set_params.py +++ b/src/mobilerun_sdk/types/devices/language_set_params.py @@ -17,9 +17,10 @@ class LanguageSetParams(TypedDict, total=False): """ restart: bool - """Restart zygote so the locale change takes full effect immediately. - - Without it, the locale is written but won't fully apply until the next reboot. + """ + Restart the Android system framework so the locale change takes full effect + immediately; open apps are closed. Without it, the change may not fully apply + until the next reboot. Some devices ignore this flag. """ x_device_display_id: Annotated[int, PropertyInfo(alias="X-Device-Display-ID")] diff --git a/src/mobilerun_sdk/types/mailboxes/__init__.py b/src/mobilerun_sdk/types/mailboxes/__init__.py index 930243b3..9ae5cd5c 100644 --- a/src/mobilerun_sdk/types/mailboxes/__init__.py +++ b/src/mobilerun_sdk/types/mailboxes/__init__.py @@ -4,6 +4,7 @@ from .message_list_params import MessageListParams as MessageListParams from .message_list_response import MessageListResponse as MessageListResponse +from .message_retrieve_params import MessageRetrieveParams as MessageRetrieveParams from .connection_create_params import ConnectionCreateParams as ConnectionCreateParams from .message_retrieve_response import MessageRetrieveResponse as MessageRetrieveResponse from .connection_create_response import ConnectionCreateResponse as ConnectionCreateResponse diff --git a/src/mobilerun_sdk/types/mailboxes/message_retrieve_params.py b/src/mobilerun_sdk/types/mailboxes/message_retrieve_params.py new file mode 100644 index 00000000..efae7a8a --- /dev/null +++ b/src/mobilerun_sdk/types/mailboxes/message_retrieve_params.py @@ -0,0 +1,16 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing_extensions import Literal, Required, Annotated, TypedDict + +from ..._utils import PropertyInfo + +__all__ = ["MessageRetrieveParams"] + + +class MessageRetrieveParams(TypedDict, total=False): + mailbox_id: Required[Annotated[str, PropertyInfo(alias="mailboxId")]] + + include_html: Annotated[Literal["true", "false"], PropertyInfo(alias="includeHtml")] + """Return the raw HTML part as htmlBody (untrusted; render isolated).""" diff --git a/src/mobilerun_sdk/types/mailboxes/message_retrieve_response.py b/src/mobilerun_sdk/types/mailboxes/message_retrieve_response.py index 71216e32..466d3e28 100644 --- a/src/mobilerun_sdk/types/mailboxes/message_retrieve_response.py +++ b/src/mobilerun_sdk/types/mailboxes/message_retrieve_response.py @@ -39,6 +39,14 @@ class Data(BaseModel): text_body: Optional[str] = FieldInfo(alias="textBody", default=None) + html_body: Optional[str] = FieldInfo(alias="htmlBody", default=None) + """Raw HTML part as received. + + Present only with includeHtml=true; null when the mail has no HTML part or it + exceeds 1 MiB (UTF-8 bytes). Untrusted content: render only in an isolated + sandboxed frame, never inline. + """ + class MessageRetrieveResponse(BaseModel): data: Data diff --git a/src/mobilerun_sdk/types/message_list_params.py b/src/mobilerun_sdk/types/message_list_params.py index 98ed9356..90bcc2c3 100644 --- a/src/mobilerun_sdk/types/message_list_params.py +++ b/src/mobilerun_sdk/types/message_list_params.py @@ -27,3 +27,8 @@ class MessageListParams(TypedDict, total=False): status: Literal[ "all", "received", "queued", "claimed", "sending", "sent", "sent_unconfirmed", "delivered", "failed" ] + """Filter by message status. + + `delivered` and `sent_unconfirmed` are kept for compatibility and are not + emitted on current lines. + """ diff --git a/src/mobilerun_sdk/types/message_list_response.py b/src/mobilerun_sdk/types/message_list_response.py index 228de0ce..1638e314 100644 --- a/src/mobilerun_sdk/types/message_list_response.py +++ b/src/mobilerun_sdk/types/message_list_response.py @@ -42,6 +42,13 @@ class Item(BaseModel): provider_code: Optional[str] = FieldInfo(alias="providerCode", default=None) status: Literal["received", "queued", "claimed", "sending", "sent", "sent_unconfirmed", "delivered", "failed"] + """Message status. + + Outbound messages move queued → sending → sent, or end at failed. `sent` means + the mobile network accepted the message and is the final success status. + `delivered` and `sent_unconfirmed` are kept for compatibility; current lines + return no carrier delivery report, so neither is emitted. + """ class MessageListResponse(BaseModel): diff --git a/src/mobilerun_sdk/types/message_retrieve_response.py b/src/mobilerun_sdk/types/message_retrieve_response.py index 7997ae1e..49b1bfcd 100644 --- a/src/mobilerun_sdk/types/message_retrieve_response.py +++ b/src/mobilerun_sdk/types/message_retrieve_response.py @@ -41,6 +41,13 @@ class Data(BaseModel): provider_code: Optional[str] = FieldInfo(alias="providerCode", default=None) status: Literal["received", "queued", "claimed", "sending", "sent", "sent_unconfirmed", "delivered", "failed"] + """Message status. + + Outbound messages move queued → sending → sent, or end at failed. `sent` means + the mobile network accepted the message and is the final success status. + `delivered` and `sent_unconfirmed` are kept for compatibility; current lines + return no carrier delivery report, so neither is emitted. + """ class MessageRetrieveResponse(BaseModel): diff --git a/src/mobilerun_sdk/types/messages/conversation_list_response.py b/src/mobilerun_sdk/types/messages/conversation_list_response.py index 6e3e622e..b6b1e8a7 100644 --- a/src/mobilerun_sdk/types/messages/conversation_list_response.py +++ b/src/mobilerun_sdk/types/messages/conversation_list_response.py @@ -21,6 +21,13 @@ class ItemLastMessage(BaseModel): occurred_at: datetime = FieldInfo(alias="occurredAt") status: Literal["received", "queued", "claimed", "sending", "sent", "sent_unconfirmed", "delivered", "failed"] + """Message status. + + Outbound messages move queued → sending → sent, or end at failed. `sent` means + the mobile network accepted the message and is the final success status. + `delivered` and `sent_unconfirmed` are kept for compatibility; current lines + return no carrier delivery report, so neither is emitted. + """ class Item(BaseModel): diff --git a/src/mobilerun_sdk/types/numbers/message_list_response.py b/src/mobilerun_sdk/types/numbers/message_list_response.py index 47152d00..0f1aa5d9 100644 --- a/src/mobilerun_sdk/types/numbers/message_list_response.py +++ b/src/mobilerun_sdk/types/numbers/message_list_response.py @@ -40,6 +40,13 @@ class Item(BaseModel): peer_number: Optional[str] = FieldInfo(alias="peerNumber", default=None) status: Literal["received", "queued", "claimed", "sending", "sent", "sent_unconfirmed", "delivered", "failed"] + """Message status. + + Outbound messages move queued → sending → sent, or end at failed. `sent` means + the mobile network accepted the message and is the final success status. + `delivered` and `sent_unconfirmed` are kept for compatibility; current lines + return no carrier delivery report, so neither is emitted. + """ class MessageListResponse(BaseModel): diff --git a/src/mobilerun_sdk/types/numbers/message_send_params.py b/src/mobilerun_sdk/types/numbers/message_send_params.py index d9c29a54..f4967b88 100644 --- a/src/mobilerun_sdk/types/numbers/message_send_params.py +++ b/src/mobilerun_sdk/types/numbers/message_send_params.py @@ -24,4 +24,8 @@ class MessageSendParams(TypedDict, total=False): """ delivery_report: Annotated[bool, PropertyInfo(alias="deliveryReport")] - """Request a delivery report. Defaults to false.""" + """Deprecated: best effort and ignored on most lines. + + Hosted SIM numbers return no carrier delivery report, so their messages end at + `sent` and no `sms.send.delivered` event follows. Defaults to false. + """ diff --git a/src/mobilerun_sdk/types/numbers/message_send_response.py b/src/mobilerun_sdk/types/numbers/message_send_response.py index 580d1e13..7a435934 100644 --- a/src/mobilerun_sdk/types/numbers/message_send_response.py +++ b/src/mobilerun_sdk/types/numbers/message_send_response.py @@ -39,6 +39,13 @@ class Data(BaseModel): peer_number: Optional[str] = FieldInfo(alias="peerNumber", default=None) status: Literal["received", "queued", "claimed", "sending", "sent", "sent_unconfirmed", "delivered", "failed"] + """Message status. + + Outbound messages move queued → sending → sent, or end at failed. `sent` means + the mobile network accepted the message and is the final success status. + `delivered` and `sent_unconfirmed` are kept for compatibility; current lines + return no carrier delivery report, so neither is emitted. + """ class MessageSendResponse(BaseModel): diff --git a/src/mobilerun_sdk/types/task_run_params.py b/src/mobilerun_sdk/types/task_run_params.py index 37ca51e2..82802fd3 100644 --- a/src/mobilerun_sdk/types/task_run_params.py +++ b/src/mobilerun_sdk/types/task_run_params.py @@ -42,7 +42,8 @@ class TaskRunParams(TypedDict, total=False): llm_model: Annotated[str, PropertyInfo(alias="llmModel")] """The LLM model identifier to use for the task (e.g. - 'mobilerun/mobile-agent-fast') + 'mobilerun/mobile-agent-fast'). When omitted with reasoning=false, the fast-mode + default model is used. """ max_steps: Annotated[int, PropertyInfo(alias="maxSteps")] diff --git a/src/mobilerun_sdk/types/task_run_streamed_params.py b/src/mobilerun_sdk/types/task_run_streamed_params.py index e9c7b0d6..35b7c29c 100644 --- a/src/mobilerun_sdk/types/task_run_streamed_params.py +++ b/src/mobilerun_sdk/types/task_run_streamed_params.py @@ -42,7 +42,8 @@ class TaskRunStreamedParams(TypedDict, total=False): llm_model: Annotated[str, PropertyInfo(alias="llmModel")] """The LLM model identifier to use for the task (e.g. - 'mobilerun/mobile-agent-fast') + 'mobilerun/mobile-agent-fast'). When omitted with reasoning=false, the fast-mode + default model is used. """ max_steps: Annotated[int, PropertyInfo(alias="maxSteps")] diff --git a/tests/api_resources/assistant/test_conversations.py b/tests/api_resources/assistant/test_conversations.py index eec108db..bfec84bd 100644 --- a/tests/api_resources/assistant/test_conversations.py +++ b/tests/api_resources/assistant/test_conversations.py @@ -373,6 +373,7 @@ def test_method_send_with_all_params(self, client: Mobilerun) -> None: message="x", session_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", agent="agent", + model="x", ) assert_matches_type(ConversationSendResponse, conversation, path=["response"]) @@ -789,6 +790,7 @@ async def test_method_send_with_all_params(self, async_client: AsyncMobilerun) - message="x", session_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", agent="agent", + model="x", ) assert_matches_type(ConversationSendResponse, conversation, path=["response"]) diff --git a/tests/api_resources/connect/test_proxies.py b/tests/api_resources/connect/test_proxies.py index 04e0080b..90a27c49 100644 --- a/tests/api_resources/connect/test_proxies.py +++ b/tests/api_resources/connect/test_proxies.py @@ -15,6 +15,7 @@ ProxyListResponse, ProxyPingResponse, ProxyUpdateResponse, + ProxyCheckoutResponse, ProxyRetrieveResponse, ProxyEnsureHealthyResponse, ProxyListConnectionsResponse, @@ -246,6 +247,48 @@ def test_path_params_cancel(self, client: Mobilerun) -> None: "", ) + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_method_checkout(self, client: Mobilerun) -> None: + proxy = client.connect.proxies.checkout( + "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + ) + assert_matches_type(ProxyCheckoutResponse, proxy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_raw_response_checkout(self, client: Mobilerun) -> None: + response = client.connect.proxies.with_raw_response.checkout( + "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + proxy = response.parse() + assert_matches_type(ProxyCheckoutResponse, proxy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_streaming_response_checkout(self, client: Mobilerun) -> None: + with client.connect.proxies.with_streaming_response.checkout( + "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + proxy = response.parse() + assert_matches_type(ProxyCheckoutResponse, proxy, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_path_params_checkout(self, client: Mobilerun) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): + client.connect.proxies.with_raw_response.checkout( + "", + ) + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_ensure_healthy(self, client: Mobilerun) -> None: @@ -631,6 +674,48 @@ async def test_path_params_cancel(self, async_client: AsyncMobilerun) -> None: "", ) + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_method_checkout(self, async_client: AsyncMobilerun) -> None: + proxy = await async_client.connect.proxies.checkout( + "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + ) + assert_matches_type(ProxyCheckoutResponse, proxy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_raw_response_checkout(self, async_client: AsyncMobilerun) -> None: + response = await async_client.connect.proxies.with_raw_response.checkout( + "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + proxy = await response.parse() + assert_matches_type(ProxyCheckoutResponse, proxy, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_streaming_response_checkout(self, async_client: AsyncMobilerun) -> None: + async with async_client.connect.proxies.with_streaming_response.checkout( + "182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + proxy = await response.parse() + assert_matches_type(ProxyCheckoutResponse, proxy, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_path_params_checkout(self, async_client: AsyncMobilerun) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): + await async_client.connect.proxies.with_raw_response.checkout( + "", + ) + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_ensure_healthy(self, async_client: AsyncMobilerun) -> None: diff --git a/tests/api_resources/credentials/onepassword/__init__.py b/tests/api_resources/credentials/onepassword/__init__.py new file mode 100644 index 00000000..fd8019a9 --- /dev/null +++ b/tests/api_resources/credentials/onepassword/__init__.py @@ -0,0 +1 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. diff --git a/tests/api_resources/credentials/onepassword/vaults/__init__.py b/tests/api_resources/credentials/onepassword/vaults/__init__.py new file mode 100644 index 00000000..fd8019a9 --- /dev/null +++ b/tests/api_resources/credentials/onepassword/vaults/__init__.py @@ -0,0 +1 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. diff --git a/tests/api_resources/credentials/onepassword/vaults/items/__init__.py b/tests/api_resources/credentials/onepassword/vaults/items/__init__.py new file mode 100644 index 00000000..fd8019a9 --- /dev/null +++ b/tests/api_resources/credentials/onepassword/vaults/items/__init__.py @@ -0,0 +1 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. diff --git a/tests/api_resources/credentials/onepassword/vaults/items/test_fields.py b/tests/api_resources/credentials/onepassword/vaults/items/test_fields.py new file mode 100644 index 00000000..605e4afd --- /dev/null +++ b/tests/api_resources/credentials/onepassword/vaults/items/test_fields.py @@ -0,0 +1,128 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +import os +from typing import Any, cast + +import pytest + +from tests.utils import assert_matches_type +from mobilerun_sdk import Mobilerun, AsyncMobilerun +from mobilerun_sdk.types.credentials.onepassword.vaults.items import FieldListResponse + +base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") + + +class TestFields: + parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_method_list(self, client: Mobilerun) -> None: + field = client.credentials.onepassword.vaults.items.fields.list( + item_id="x", + vault_id="x", + ) + assert_matches_type(FieldListResponse, field, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_raw_response_list(self, client: Mobilerun) -> None: + response = client.credentials.onepassword.vaults.items.fields.with_raw_response.list( + item_id="x", + vault_id="x", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + field = response.parse() + assert_matches_type(FieldListResponse, field, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_streaming_response_list(self, client: Mobilerun) -> None: + with client.credentials.onepassword.vaults.items.fields.with_streaming_response.list( + item_id="x", + vault_id="x", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + field = response.parse() + assert_matches_type(FieldListResponse, field, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_path_params_list(self, client: Mobilerun) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `vault_id` but received ''"): + client.credentials.onepassword.vaults.items.fields.with_raw_response.list( + item_id="x", + vault_id="", + ) + + with pytest.raises(ValueError, match=r"Expected a non-empty value for `item_id` but received ''"): + client.credentials.onepassword.vaults.items.fields.with_raw_response.list( + item_id="", + vault_id="x", + ) + + +class TestAsyncFields: + parametrize = pytest.mark.parametrize( + "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] + ) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_method_list(self, async_client: AsyncMobilerun) -> None: + field = await async_client.credentials.onepassword.vaults.items.fields.list( + item_id="x", + vault_id="x", + ) + assert_matches_type(FieldListResponse, field, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_raw_response_list(self, async_client: AsyncMobilerun) -> None: + response = await async_client.credentials.onepassword.vaults.items.fields.with_raw_response.list( + item_id="x", + vault_id="x", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + field = await response.parse() + assert_matches_type(FieldListResponse, field, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_streaming_response_list(self, async_client: AsyncMobilerun) -> None: + async with async_client.credentials.onepassword.vaults.items.fields.with_streaming_response.list( + item_id="x", + vault_id="x", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + field = await response.parse() + assert_matches_type(FieldListResponse, field, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_path_params_list(self, async_client: AsyncMobilerun) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `vault_id` but received ''"): + await async_client.credentials.onepassword.vaults.items.fields.with_raw_response.list( + item_id="x", + vault_id="", + ) + + with pytest.raises(ValueError, match=r"Expected a non-empty value for `item_id` but received ''"): + await async_client.credentials.onepassword.vaults.items.fields.with_raw_response.list( + item_id="", + vault_id="x", + ) diff --git a/tests/api_resources/credentials/onepassword/vaults/test_items.py b/tests/api_resources/credentials/onepassword/vaults/test_items.py new file mode 100644 index 00000000..33267d7e --- /dev/null +++ b/tests/api_resources/credentials/onepassword/vaults/test_items.py @@ -0,0 +1,108 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +import os +from typing import Any, cast + +import pytest + +from tests.utils import assert_matches_type +from mobilerun_sdk import Mobilerun, AsyncMobilerun +from mobilerun_sdk.types.credentials.onepassword.vaults import ItemListResponse + +base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") + + +class TestItems: + parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_method_list(self, client: Mobilerun) -> None: + item = client.credentials.onepassword.vaults.items.list( + "x", + ) + assert_matches_type(ItemListResponse, item, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_raw_response_list(self, client: Mobilerun) -> None: + response = client.credentials.onepassword.vaults.items.with_raw_response.list( + "x", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + item = response.parse() + assert_matches_type(ItemListResponse, item, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_streaming_response_list(self, client: Mobilerun) -> None: + with client.credentials.onepassword.vaults.items.with_streaming_response.list( + "x", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + item = response.parse() + assert_matches_type(ItemListResponse, item, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_path_params_list(self, client: Mobilerun) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `vault_id` but received ''"): + client.credentials.onepassword.vaults.items.with_raw_response.list( + "", + ) + + +class TestAsyncItems: + parametrize = pytest.mark.parametrize( + "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] + ) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_method_list(self, async_client: AsyncMobilerun) -> None: + item = await async_client.credentials.onepassword.vaults.items.list( + "x", + ) + assert_matches_type(ItemListResponse, item, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_raw_response_list(self, async_client: AsyncMobilerun) -> None: + response = await async_client.credentials.onepassword.vaults.items.with_raw_response.list( + "x", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + item = await response.parse() + assert_matches_type(ItemListResponse, item, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_streaming_response_list(self, async_client: AsyncMobilerun) -> None: + async with async_client.credentials.onepassword.vaults.items.with_streaming_response.list( + "x", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + item = await response.parse() + assert_matches_type(ItemListResponse, item, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_path_params_list(self, async_client: AsyncMobilerun) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `vault_id` but received ''"): + await async_client.credentials.onepassword.vaults.items.with_raw_response.list( + "", + ) diff --git a/tests/api_resources/credentials/packages/test_credentials.py b/tests/api_resources/credentials/packages/test_credentials.py index 06dd0e99..2b0f7245 100644 --- a/tests/api_resources/credentials/packages/test_credentials.py +++ b/tests/api_resources/credentials/packages/test_credentials.py @@ -12,7 +12,6 @@ from mobilerun_sdk.types.credentials.packages import ( CredentialCreateResponse, CredentialDeleteResponse, - CredentialRetrieveResponse, ) base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -91,58 +90,6 @@ def test_path_params_create(self, client: Mobilerun) -> None: ], ) - @pytest.mark.skip(reason="Mock server tests are disabled") - @parametrize - def test_method_retrieve(self, client: Mobilerun) -> None: - credential = client.credentials.packages.credentials.retrieve( - credential_name="26f1kl_-n-71", - package_name="x", - ) - assert_matches_type(CredentialRetrieveResponse, credential, path=["response"]) - - @pytest.mark.skip(reason="Mock server tests are disabled") - @parametrize - def test_raw_response_retrieve(self, client: Mobilerun) -> None: - response = client.credentials.packages.credentials.with_raw_response.retrieve( - credential_name="26f1kl_-n-71", - package_name="x", - ) - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - credential = response.parse() - assert_matches_type(CredentialRetrieveResponse, credential, path=["response"]) - - @pytest.mark.skip(reason="Mock server tests are disabled") - @parametrize - def test_streaming_response_retrieve(self, client: Mobilerun) -> None: - with client.credentials.packages.credentials.with_streaming_response.retrieve( - credential_name="26f1kl_-n-71", - package_name="x", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - credential = response.parse() - assert_matches_type(CredentialRetrieveResponse, credential, path=["response"]) - - assert cast(Any, response.is_closed) is True - - @pytest.mark.skip(reason="Mock server tests are disabled") - @parametrize - def test_path_params_retrieve(self, client: Mobilerun) -> None: - with pytest.raises(ValueError, match=r"Expected a non-empty value for `package_name` but received ''"): - client.credentials.packages.credentials.with_raw_response.retrieve( - credential_name="26f1kl_-n-71", - package_name="", - ) - - with pytest.raises(ValueError, match=r"Expected a non-empty value for `credential_name` but received ''"): - client.credentials.packages.credentials.with_raw_response.retrieve( - credential_name="", - package_name="x", - ) - @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_delete(self, client: Mobilerun) -> None: @@ -271,58 +218,6 @@ async def test_path_params_create(self, async_client: AsyncMobilerun) -> None: ], ) - @pytest.mark.skip(reason="Mock server tests are disabled") - @parametrize - async def test_method_retrieve(self, async_client: AsyncMobilerun) -> None: - credential = await async_client.credentials.packages.credentials.retrieve( - credential_name="26f1kl_-n-71", - package_name="x", - ) - assert_matches_type(CredentialRetrieveResponse, credential, path=["response"]) - - @pytest.mark.skip(reason="Mock server tests are disabled") - @parametrize - async def test_raw_response_retrieve(self, async_client: AsyncMobilerun) -> None: - response = await async_client.credentials.packages.credentials.with_raw_response.retrieve( - credential_name="26f1kl_-n-71", - package_name="x", - ) - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - credential = await response.parse() - assert_matches_type(CredentialRetrieveResponse, credential, path=["response"]) - - @pytest.mark.skip(reason="Mock server tests are disabled") - @parametrize - async def test_streaming_response_retrieve(self, async_client: AsyncMobilerun) -> None: - async with async_client.credentials.packages.credentials.with_streaming_response.retrieve( - credential_name="26f1kl_-n-71", - package_name="x", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - credential = await response.parse() - assert_matches_type(CredentialRetrieveResponse, credential, path=["response"]) - - assert cast(Any, response.is_closed) is True - - @pytest.mark.skip(reason="Mock server tests are disabled") - @parametrize - async def test_path_params_retrieve(self, async_client: AsyncMobilerun) -> None: - with pytest.raises(ValueError, match=r"Expected a non-empty value for `package_name` but received ''"): - await async_client.credentials.packages.credentials.with_raw_response.retrieve( - credential_name="26f1kl_-n-71", - package_name="", - ) - - with pytest.raises(ValueError, match=r"Expected a non-empty value for `credential_name` but received ''"): - await async_client.credentials.packages.credentials.with_raw_response.retrieve( - credential_name="", - package_name="x", - ) - @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_delete(self, async_client: AsyncMobilerun) -> None: diff --git a/tests/api_resources/credentials/packages/test_links.py b/tests/api_resources/credentials/packages/test_links.py new file mode 100644 index 00000000..3ed483e0 --- /dev/null +++ b/tests/api_resources/credentials/packages/test_links.py @@ -0,0 +1,180 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +import os +from typing import Any, cast + +import pytest + +from tests.utils import assert_matches_type +from mobilerun_sdk import Mobilerun, AsyncMobilerun +from mobilerun_sdk.types.credentials.packages import LinkCreateResponse + +base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") + + +class TestLinks: + parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_method_create(self, client: Mobilerun) -> None: + link = client.credentials.packages.links.create( + package_name="x", + credential_name="26f1kl_-n-71", + field_map=[ + { + "field_id": "x", + "field_type": "email", + } + ], + item_id="x", + vault_id="x", + ) + assert_matches_type(LinkCreateResponse, link, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_raw_response_create(self, client: Mobilerun) -> None: + response = client.credentials.packages.links.with_raw_response.create( + package_name="x", + credential_name="26f1kl_-n-71", + field_map=[ + { + "field_id": "x", + "field_type": "email", + } + ], + item_id="x", + vault_id="x", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + link = response.parse() + assert_matches_type(LinkCreateResponse, link, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_streaming_response_create(self, client: Mobilerun) -> None: + with client.credentials.packages.links.with_streaming_response.create( + package_name="x", + credential_name="26f1kl_-n-71", + field_map=[ + { + "field_id": "x", + "field_type": "email", + } + ], + item_id="x", + vault_id="x", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + link = response.parse() + assert_matches_type(LinkCreateResponse, link, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_path_params_create(self, client: Mobilerun) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `package_name` but received ''"): + client.credentials.packages.links.with_raw_response.create( + package_name="", + credential_name="26f1kl_-n-71", + field_map=[ + { + "field_id": "x", + "field_type": "email", + } + ], + item_id="x", + vault_id="x", + ) + + +class TestAsyncLinks: + parametrize = pytest.mark.parametrize( + "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] + ) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_method_create(self, async_client: AsyncMobilerun) -> None: + link = await async_client.credentials.packages.links.create( + package_name="x", + credential_name="26f1kl_-n-71", + field_map=[ + { + "field_id": "x", + "field_type": "email", + } + ], + item_id="x", + vault_id="x", + ) + assert_matches_type(LinkCreateResponse, link, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_raw_response_create(self, async_client: AsyncMobilerun) -> None: + response = await async_client.credentials.packages.links.with_raw_response.create( + package_name="x", + credential_name="26f1kl_-n-71", + field_map=[ + { + "field_id": "x", + "field_type": "email", + } + ], + item_id="x", + vault_id="x", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + link = await response.parse() + assert_matches_type(LinkCreateResponse, link, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_streaming_response_create(self, async_client: AsyncMobilerun) -> None: + async with async_client.credentials.packages.links.with_streaming_response.create( + package_name="x", + credential_name="26f1kl_-n-71", + field_map=[ + { + "field_id": "x", + "field_type": "email", + } + ], + item_id="x", + vault_id="x", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + link = await response.parse() + assert_matches_type(LinkCreateResponse, link, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_path_params_create(self, async_client: AsyncMobilerun) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `package_name` but received ''"): + await async_client.credentials.packages.links.with_raw_response.create( + package_name="", + credential_name="26f1kl_-n-71", + field_map=[ + { + "field_id": "x", + "field_type": "email", + } + ], + item_id="x", + vault_id="x", + ) diff --git a/tests/api_resources/credentials/test_onepassword.py b/tests/api_resources/credentials/test_onepassword.py new file mode 100644 index 00000000..821edfa9 --- /dev/null +++ b/tests/api_resources/credentials/test_onepassword.py @@ -0,0 +1,208 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +import os +from typing import Any, cast + +import pytest + +from tests.utils import assert_matches_type +from mobilerun_sdk import Mobilerun, AsyncMobilerun +from mobilerun_sdk.types.credentials import ( + OnepasswordConnectResponse, + OnepasswordRetrieveResponse, + OnepasswordDisconnectResponse, +) + +base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") + + +class TestOnepassword: + parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_method_retrieve(self, client: Mobilerun) -> None: + onepassword = client.credentials.onepassword.retrieve() + assert_matches_type(OnepasswordRetrieveResponse, onepassword, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_raw_response_retrieve(self, client: Mobilerun) -> None: + response = client.credentials.onepassword.with_raw_response.retrieve() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + onepassword = response.parse() + assert_matches_type(OnepasswordRetrieveResponse, onepassword, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_streaming_response_retrieve(self, client: Mobilerun) -> None: + with client.credentials.onepassword.with_streaming_response.retrieve() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + onepassword = response.parse() + assert_matches_type(OnepasswordRetrieveResponse, onepassword, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_method_connect(self, client: Mobilerun) -> None: + onepassword = client.credentials.onepassword.connect( + service_account_token="serviceAccountToken", + ) + assert_matches_type(OnepasswordConnectResponse, onepassword, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_raw_response_connect(self, client: Mobilerun) -> None: + response = client.credentials.onepassword.with_raw_response.connect( + service_account_token="serviceAccountToken", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + onepassword = response.parse() + assert_matches_type(OnepasswordConnectResponse, onepassword, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_streaming_response_connect(self, client: Mobilerun) -> None: + with client.credentials.onepassword.with_streaming_response.connect( + service_account_token="serviceAccountToken", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + onepassword = response.parse() + assert_matches_type(OnepasswordConnectResponse, onepassword, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_method_disconnect(self, client: Mobilerun) -> None: + onepassword = client.credentials.onepassword.disconnect() + assert_matches_type(OnepasswordDisconnectResponse, onepassword, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_raw_response_disconnect(self, client: Mobilerun) -> None: + response = client.credentials.onepassword.with_raw_response.disconnect() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + onepassword = response.parse() + assert_matches_type(OnepasswordDisconnectResponse, onepassword, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_streaming_response_disconnect(self, client: Mobilerun) -> None: + with client.credentials.onepassword.with_streaming_response.disconnect() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + onepassword = response.parse() + assert_matches_type(OnepasswordDisconnectResponse, onepassword, path=["response"]) + + assert cast(Any, response.is_closed) is True + + +class TestAsyncOnepassword: + parametrize = pytest.mark.parametrize( + "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] + ) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_method_retrieve(self, async_client: AsyncMobilerun) -> None: + onepassword = await async_client.credentials.onepassword.retrieve() + assert_matches_type(OnepasswordRetrieveResponse, onepassword, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_raw_response_retrieve(self, async_client: AsyncMobilerun) -> None: + response = await async_client.credentials.onepassword.with_raw_response.retrieve() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + onepassword = await response.parse() + assert_matches_type(OnepasswordRetrieveResponse, onepassword, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_streaming_response_retrieve(self, async_client: AsyncMobilerun) -> None: + async with async_client.credentials.onepassword.with_streaming_response.retrieve() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + onepassword = await response.parse() + assert_matches_type(OnepasswordRetrieveResponse, onepassword, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_method_connect(self, async_client: AsyncMobilerun) -> None: + onepassword = await async_client.credentials.onepassword.connect( + service_account_token="serviceAccountToken", + ) + assert_matches_type(OnepasswordConnectResponse, onepassword, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_raw_response_connect(self, async_client: AsyncMobilerun) -> None: + response = await async_client.credentials.onepassword.with_raw_response.connect( + service_account_token="serviceAccountToken", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + onepassword = await response.parse() + assert_matches_type(OnepasswordConnectResponse, onepassword, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_streaming_response_connect(self, async_client: AsyncMobilerun) -> None: + async with async_client.credentials.onepassword.with_streaming_response.connect( + service_account_token="serviceAccountToken", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + onepassword = await response.parse() + assert_matches_type(OnepasswordConnectResponse, onepassword, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_method_disconnect(self, async_client: AsyncMobilerun) -> None: + onepassword = await async_client.credentials.onepassword.disconnect() + assert_matches_type(OnepasswordDisconnectResponse, onepassword, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_raw_response_disconnect(self, async_client: AsyncMobilerun) -> None: + response = await async_client.credentials.onepassword.with_raw_response.disconnect() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + onepassword = await response.parse() + assert_matches_type(OnepasswordDisconnectResponse, onepassword, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_streaming_response_disconnect(self, async_client: AsyncMobilerun) -> None: + async with async_client.credentials.onepassword.with_streaming_response.disconnect() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + onepassword = await response.parse() + assert_matches_type(OnepasswordDisconnectResponse, onepassword, path=["response"]) + + assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/mailboxes/test_messages.py b/tests/api_resources/mailboxes/test_messages.py index ad736d6a..a0f4eafc 100644 --- a/tests/api_resources/mailboxes/test_messages.py +++ b/tests/api_resources/mailboxes/test_messages.py @@ -10,7 +10,10 @@ from tests.utils import assert_matches_type from mobilerun_sdk import Mobilerun, AsyncMobilerun from mobilerun_sdk._utils import parse_datetime -from mobilerun_sdk.types.mailboxes import MessageListResponse, MessageRetrieveResponse +from mobilerun_sdk.types.mailboxes import ( + MessageListResponse, + MessageRetrieveResponse, +) base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -27,6 +30,16 @@ def test_method_retrieve(self, client: Mobilerun) -> None: ) assert_matches_type(MessageRetrieveResponse, message, path=["response"]) + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_method_retrieve_with_all_params(self, client: Mobilerun) -> None: + message = client.mailboxes.messages.retrieve( + message_id="x", + mailbox_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + include_html="true", + ) + assert_matches_type(MessageRetrieveResponse, message, path=["response"]) + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_retrieve(self, client: Mobilerun) -> None: @@ -140,6 +153,16 @@ async def test_method_retrieve(self, async_client: AsyncMobilerun) -> None: ) assert_matches_type(MessageRetrieveResponse, message, path=["response"]) + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_method_retrieve_with_all_params(self, async_client: AsyncMobilerun) -> None: + message = await async_client.mailboxes.messages.retrieve( + message_id="x", + mailbox_id="182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e", + include_html="true", + ) + assert_matches_type(MessageRetrieveResponse, message, path=["response"]) + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_retrieve(self, async_client: AsyncMobilerun) -> None: diff --git a/tests/api_resources/test_devices.py b/tests/api_resources/test_devices.py index 1d36cf32..11ea1709 100644 --- a/tests/api_resources/test_devices.py +++ b/tests/api_resources/test_devices.py @@ -44,6 +44,7 @@ def test_method_create_with_all_params(self, client: Mobilerun) -> None: query_country="country", device_type="android_cloud_phone", profile_id="profileId", + template="onboarding", android_version=0, apps=["string"], carrier={ @@ -350,6 +351,7 @@ def test_method_reset_with_all_params(self, client: Mobilerun) -> None: device = client.devices.reset( device_id="deviceId", mode="full", + preserve=["proxy"], ) assert device is None @@ -709,6 +711,7 @@ async def test_method_create_with_all_params(self, async_client: AsyncMobilerun) query_country="country", device_type="android_cloud_phone", profile_id="profileId", + template="onboarding", android_version=0, apps=["string"], carrier={ @@ -1015,6 +1018,7 @@ async def test_method_reset_with_all_params(self, async_client: AsyncMobilerun) device = await async_client.devices.reset( device_id="deviceId", mode="full", + preserve=["proxy"], ) assert device is None