payi 0.1.0a104__py3-none-any.whl → 0.1.0a105__py3-none-any.whl

payi/resources/requests/response_id/properties.py

@@ -0,0 +1,181 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict
+
+import httpx
+
+from ...._types import NOT_GIVEN, Body, Query, Headers, NotGiven
+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 ...._base_client import make_request_options
+from ....types.requests.response_id import property_update_params
+from ....types.shared.properties_response import PropertiesResponse
+
+__all__ = ["PropertiesResource", "AsyncPropertiesResource"]
+
+
+class PropertiesResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> PropertiesResourceWithRawResponse:
+        """
+        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/Pay-i/pay-i-python#accessing-raw-response-data-eg-headers
+        """
+        return PropertiesResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> PropertiesResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/Pay-i/pay-i-python#with_streaming_response
+        """
+        return PropertiesResourceWithStreamingResponse(self)
+
+    def update(
+        self,
+        provider_response_id: str,
+        *,
+        category: str,
+        properties: Dict[str, 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,
+    ) -> PropertiesResponse:
+        """
+        Update Request properties
+
+        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 category:
+            raise ValueError(f"Expected a non-empty value for `category` but received {category!r}")
+        if not provider_response_id:
+            raise ValueError(
+                f"Expected a non-empty value for `provider_response_id` but received {provider_response_id!r}"
+            )
+        return self._put(
+            f"/api/v1/requests/provider/{category}/{provider_response_id}/properties",
+            body=maybe_transform({"properties": properties}, property_update_params.PropertyUpdateParams),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=PropertiesResponse,
+        )
+
+
+class AsyncPropertiesResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncPropertiesResourceWithRawResponse:
+        """
+        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/Pay-i/pay-i-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncPropertiesResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncPropertiesResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/Pay-i/pay-i-python#with_streaming_response
+        """
+        return AsyncPropertiesResourceWithStreamingResponse(self)
+
+    async def update(
+        self,
+        provider_response_id: str,
+        *,
+        category: str,
+        properties: Dict[str, 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,
+    ) -> PropertiesResponse:
+        """
+        Update Request properties
+
+        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 category:
+            raise ValueError(f"Expected a non-empty value for `category` but received {category!r}")
+        if not provider_response_id:
+            raise ValueError(
+                f"Expected a non-empty value for `provider_response_id` but received {provider_response_id!r}"
+            )
+        return await self._put(
+            f"/api/v1/requests/provider/{category}/{provider_response_id}/properties",
+            body=await async_maybe_transform({"properties": properties}, property_update_params.PropertyUpdateParams),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=PropertiesResponse,
+        )
+
+
+class PropertiesResourceWithRawResponse:
+    def __init__(self, properties: PropertiesResource) -> None:
+        self._properties = properties
+
+        self.update = to_raw_response_wrapper(
+            properties.update,
+        )
+
+
+class AsyncPropertiesResourceWithRawResponse:
+    def __init__(self, properties: AsyncPropertiesResource) -> None:
+        self._properties = properties
+
+        self.update = async_to_raw_response_wrapper(
+            properties.update,
+        )
+
+
+class PropertiesResourceWithStreamingResponse:
+    def __init__(self, properties: PropertiesResource) -> None:
+        self._properties = properties
+
+        self.update = to_streamed_response_wrapper(
+            properties.update,
+        )
+
+
+class AsyncPropertiesResourceWithStreamingResponse:
+    def __init__(self, properties: AsyncPropertiesResource) -> None:
+        self._properties = properties
+
+        self.update = async_to_streamed_response_wrapper(
+            properties.update,
+        )

payi/resources/requests/response_id/response_id.py

@@ -0,0 +1,134 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .result import (
+    ResultResource,
+    AsyncResultResource,
+    ResultResourceWithRawResponse,
+    AsyncResultResourceWithRawResponse,
+    ResultResourceWithStreamingResponse,
+    AsyncResultResourceWithStreamingResponse,
+)
+from ...._compat import cached_property
+from .properties import (
+    PropertiesResource,
+    AsyncPropertiesResource,
+    PropertiesResourceWithRawResponse,
+    AsyncPropertiesResourceWithRawResponse,
+    PropertiesResourceWithStreamingResponse,
+    AsyncPropertiesResourceWithStreamingResponse,
+)
+from ...._resource import SyncAPIResource, AsyncAPIResource
+
+__all__ = ["ResponseIDResource", "AsyncResponseIDResource"]
+
+
+class ResponseIDResource(SyncAPIResource):
+    @cached_property
+    def result(self) -> ResultResource:
+        return ResultResource(self._client)
+
+    @cached_property
+    def properties(self) -> PropertiesResource:
+        return PropertiesResource(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> ResponseIDResourceWithRawResponse:
+        """
+        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/Pay-i/pay-i-python#accessing-raw-response-data-eg-headers
+        """
+        return ResponseIDResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> ResponseIDResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/Pay-i/pay-i-python#with_streaming_response
+        """
+        return ResponseIDResourceWithStreamingResponse(self)
+
+
+class AsyncResponseIDResource(AsyncAPIResource):
+    @cached_property
+    def result(self) -> AsyncResultResource:
+        return AsyncResultResource(self._client)
+
+    @cached_property
+    def properties(self) -> AsyncPropertiesResource:
+        return AsyncPropertiesResource(self._client)
+
+    @cached_property
+    def with_raw_response(self) -> AsyncResponseIDResourceWithRawResponse:
+        """
+        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/Pay-i/pay-i-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncResponseIDResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncResponseIDResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/Pay-i/pay-i-python#with_streaming_response
+        """
+        return AsyncResponseIDResourceWithStreamingResponse(self)
+
+
+class ResponseIDResourceWithRawResponse:
+    def __init__(self, response_id: ResponseIDResource) -> None:
+        self._response_id = response_id
+
+    @cached_property
+    def result(self) -> ResultResourceWithRawResponse:
+        return ResultResourceWithRawResponse(self._response_id.result)
+
+    @cached_property
+    def properties(self) -> PropertiesResourceWithRawResponse:
+        return PropertiesResourceWithRawResponse(self._response_id.properties)
+
+
+class AsyncResponseIDResourceWithRawResponse:
+    def __init__(self, response_id: AsyncResponseIDResource) -> None:
+        self._response_id = response_id
+
+    @cached_property
+    def result(self) -> AsyncResultResourceWithRawResponse:
+        return AsyncResultResourceWithRawResponse(self._response_id.result)
+
+    @cached_property
+    def properties(self) -> AsyncPropertiesResourceWithRawResponse:
+        return AsyncPropertiesResourceWithRawResponse(self._response_id.properties)
+
+
+class ResponseIDResourceWithStreamingResponse:
+    def __init__(self, response_id: ResponseIDResource) -> None:
+        self._response_id = response_id
+
+    @cached_property
+    def result(self) -> ResultResourceWithStreamingResponse:
+        return ResultResourceWithStreamingResponse(self._response_id.result)
+
+    @cached_property
+    def properties(self) -> PropertiesResourceWithStreamingResponse:
+        return PropertiesResourceWithStreamingResponse(self._response_id.properties)
+
+
+class AsyncResponseIDResourceWithStreamingResponse:
+    def __init__(self, response_id: AsyncResponseIDResource) -> None:
+        self._response_id = response_id
+
+    @cached_property
+    def result(self) -> AsyncResultResourceWithStreamingResponse:
+        return AsyncResultResourceWithStreamingResponse(self._response_id.result)
+
+    @cached_property
+    def properties(self) -> AsyncPropertiesResourceWithStreamingResponse:
+        return AsyncPropertiesResourceWithStreamingResponse(self._response_id.properties)

payi/resources/requests/response_id/result.py

@@ -0,0 +1,173 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import httpx
+
+from ...._types import NOT_GIVEN, Body, Query, Headers, NotGiven
+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.request_result import RequestResult
+
+__all__ = ["ResultResource", "AsyncResultResource"]
+
+
+class ResultResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> ResultResourceWithRawResponse:
+        """
+        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/Pay-i/pay-i-python#accessing-raw-response-data-eg-headers
+        """
+        return ResultResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> ResultResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/Pay-i/pay-i-python#with_streaming_response
+        """
+        return ResultResourceWithStreamingResponse(self)
+
+    def retrieve(
+        self,
+        provider_response_id: str,
+        *,
+        category: 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,
+    ) -> RequestResult:
+        """
+        Get a Request results
+
+        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 category:
+            raise ValueError(f"Expected a non-empty value for `category` but received {category!r}")
+        if not provider_response_id:
+            raise ValueError(
+                f"Expected a non-empty value for `provider_response_id` but received {provider_response_id!r}"
+            )
+        return self._get(
+            f"/api/v1/requests/provider/{category}/{provider_response_id}/result",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=RequestResult,
+        )
+
+
+class AsyncResultResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncResultResourceWithRawResponse:
+        """
+        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/Pay-i/pay-i-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncResultResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncResultResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/Pay-i/pay-i-python#with_streaming_response
+        """
+        return AsyncResultResourceWithStreamingResponse(self)
+
+    async def retrieve(
+        self,
+        provider_response_id: str,
+        *,
+        category: 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,
+    ) -> RequestResult:
+        """
+        Get a Request results
+
+        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 category:
+            raise ValueError(f"Expected a non-empty value for `category` but received {category!r}")
+        if not provider_response_id:
+            raise ValueError(
+                f"Expected a non-empty value for `provider_response_id` but received {provider_response_id!r}"
+            )
+        return await self._get(
+            f"/api/v1/requests/provider/{category}/{provider_response_id}/result",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=RequestResult,
+        )
+
+
+class ResultResourceWithRawResponse:
+    def __init__(self, result: ResultResource) -> None:
+        self._result = result
+
+        self.retrieve = to_raw_response_wrapper(
+            result.retrieve,
+        )
+
+
+class AsyncResultResourceWithRawResponse:
+    def __init__(self, result: AsyncResultResource) -> None:
+        self._result = result
+
+        self.retrieve = async_to_raw_response_wrapper(
+            result.retrieve,
+        )
+
+
+class ResultResourceWithStreamingResponse:
+    def __init__(self, result: ResultResource) -> None:
+        self._result = result
+
+        self.retrieve = to_streamed_response_wrapper(
+            result.retrieve,
+        )
+
+
+class AsyncResultResourceWithStreamingResponse:
+    def __init__(self, result: AsyncResultResource) -> None:
+        self._result = result
+
+        self.retrieve = async_to_streamed_response_wrapper(
+            result.retrieve,
+        )

payi/resources/use_cases/properties.py

@@ -17,7 +17,7 @@ from ..._response import (
     async_to_streamed_response_wrapper,
 )
 from ..._base_client import make_request_options
-from ...types.use_cases import property_create_params
+from ...types.use_cases import property_update_params
 from ...types.use_cases.property_create_response import PropertyCreateResponse
 
 __all__ = ["PropertiesResource", "AsyncPropertiesResource"]
@@ -43,7 +43,7 @@ class PropertiesResource(SyncAPIResource):
         """
         return PropertiesResourceWithStreamingResponse(self)
 
-    def create(
+    def update(
         self,
         use_case_id: str,
         *,
@@ -69,9 +69,9 @@ class PropertiesResource(SyncAPIResource):
         """
         if not use_case_id:
             raise ValueError(f"Expected a non-empty value for `use_case_id` but received {use_case_id!r}")
-        return self._post(
+        return self._put(
             f"/api/v1/use_cases/instances/{use_case_id}/properties",
-            body=maybe_transform({"properties": properties}, property_create_params.PropertyCreateParams),
+            body=maybe_transform({"properties": properties}, property_update_params.PropertyUpdateParams),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
@@ -99,7 +99,7 @@ class AsyncPropertiesResource(AsyncAPIResource):
         """
         return AsyncPropertiesResourceWithStreamingResponse(self)
 
-    async def create(
+    async def update(
         self,
         use_case_id: str,
         *,
@@ -125,9 +125,9 @@ class AsyncPropertiesResource(AsyncAPIResource):
         """
         if not use_case_id:
             raise ValueError(f"Expected a non-empty value for `use_case_id` but received {use_case_id!r}")
-        return await self._post(
+        return await self._put(
             f"/api/v1/use_cases/instances/{use_case_id}/properties",
-            body=await async_maybe_transform({"properties": properties}, property_create_params.PropertyCreateParams),
+            body=await async_maybe_transform({"properties": properties}, property_update_params.PropertyUpdateParams),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
@@ -139,8 +139,8 @@ class PropertiesResourceWithRawResponse:
     def __init__(self, properties: PropertiesResource) -> None:
         self._properties = properties
 
-        self.create = to_raw_response_wrapper(
-            properties.create,
+        self.update = to_raw_response_wrapper(
+            properties.update,
         )
 
 
@@ -148,8 +148,8 @@ class AsyncPropertiesResourceWithRawResponse:
     def __init__(self, properties: AsyncPropertiesResource) -> None:
         self._properties = properties
 
-        self.create = async_to_raw_response_wrapper(
-            properties.create,
+        self.update = async_to_raw_response_wrapper(
+            properties.update,
         )
 
 
@@ -157,8 +157,8 @@ class PropertiesResourceWithStreamingResponse:
     def __init__(self, properties: PropertiesResource) -> None:
         self._properties = properties
 
-        self.create = to_streamed_response_wrapper(
-            properties.create,
+        self.update = to_streamed_response_wrapper(
+            properties.update,
         )
 
 
@@ -166,6 +166,6 @@ class AsyncPropertiesResourceWithStreamingResponse:
     def __init__(self, properties: AsyncPropertiesResource) -> None:
         self._properties = properties
 
-        self.create = async_to_streamed_response_wrapper(
-            properties.create,
+        self.update = async_to_streamed_response_wrapper(
+            properties.update,
         )

payi/types/__init__.py

@@ -14,6 +14,7 @@ from .cost_data import CostData as CostData
 from .cost_details import CostDetails as CostDetails
 from .requests_data import RequestsData as RequestsData
 from .limit_response import LimitResponse as LimitResponse
+from .request_result import RequestResult as RequestResult
 from .ingest_response import IngestResponse as IngestResponse
 from .total_cost_data import TotalCostData as TotalCostData
 from .default_response import DefaultResponse as DefaultResponse

payi/types/{requests/request_result.py → request_result.py}

@@ -1,7 +1,7 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-from ..._models import BaseModel
-from ..shared.xproxy_result import XproxyResult
+from .._models import BaseModel
+from .shared.xproxy_result import XproxyResult
 
 __all__ = ["RequestResult"]
 

payi/types/requests/__init__.py

@@ -1,6 +1,3 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 from __future__ import annotations
-
-from .request_result import RequestResult as RequestResult
-from .property_create_params import PropertyCreateParams as PropertyCreateParams

payi/types/requests/request_id/__init__.py

@@ -0,0 +1,5 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .property_update_params import PropertyUpdateParams as PropertyUpdateParams

payi/types/requests/{property_create_params.py → request_id/property_update_params.py}

@@ -5,8 +5,8 @@ from __future__ import annotations
 from typing import Dict
 from typing_extensions import Required, TypedDict
 
-__all__ = ["PropertyCreateParams"]
+__all__ = ["PropertyUpdateParams"]
 
 
-class PropertyCreateParams(TypedDict, total=False):
+class PropertyUpdateParams(TypedDict, total=False):
     properties: Required[Dict[str, str]]

payi/types/requests/response_id/__init__.py

@@ -0,0 +1,5 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .property_update_params import PropertyUpdateParams as PropertyUpdateParams

payi/types/requests/response_id/property_update_params.py

@@ -0,0 +1,14 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict
+from typing_extensions import Required, TypedDict
+
+__all__ = ["PropertyUpdateParams"]
+
+
+class PropertyUpdateParams(TypedDict, total=False):
+    category: Required[str]
+
+    properties: Required[Dict[str, str]]

payi/types/shared/xproxy_result.py

@@ -44,6 +44,8 @@ class XproxyResult(BaseModel):
 
     use_case_id: Optional[str] = None
 
+    use_case_name: Optional[str] = None
+
     use_case_step: Optional[str] = None
 
     user_id: Optional[str] = None

payi/types/use_cases/__init__.py

@@ -7,7 +7,7 @@ from .kpi_list_response import KpiListResponse as KpiListResponse
 from .kpi_update_params import KpiUpdateParams as KpiUpdateParams
 from .use_case_definition import UseCaseDefinition as UseCaseDefinition
 from .definition_list_params import DefinitionListParams as DefinitionListParams
-from .property_create_params import PropertyCreateParams as PropertyCreateParams
+from .property_update_params import PropertyUpdateParams as PropertyUpdateParams
 from .definition_create_params import DefinitionCreateParams as DefinitionCreateParams
 from .definition_update_params import DefinitionUpdateParams as DefinitionUpdateParams
 from .property_create_response import PropertyCreateResponse as PropertyCreateResponse

payi/types/use_cases/{property_create_params.py → property_update_params.py}

@@ -5,8 +5,8 @@ from __future__ import annotations
 from typing import Dict
 from typing_extensions import Required, TypedDict
 
-__all__ = ["PropertyCreateParams"]
+__all__ = ["PropertyUpdateParams"]
 
 
-class PropertyCreateParams(TypedDict, total=False):
+class PropertyUpdateParams(TypedDict, total=False):
     properties: Required[Dict[str, str]]