From 73363ff764d6e305318dec07121d4e4b36c3bde2 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 27 Apr 2026 16:33:51 +0000 Subject: [PATCH 1/2] feat(api): api update --- .stats.yml | 8 +- api.md | 27 +- src/increase/_client.py | 78 ++- src/increase/resources/__init__.py | 42 +- src/increase/resources/inbound_mail_items.py | 20 +- .../{lockboxes.py => lockbox_addresses.py} | 270 ++++---- src/increase/resources/lockbox_recipients.py | 592 ++++++++++++++++++ .../simulations/inbound_mail_items.py | 24 +- src/increase/types/__init__.py | 12 +- src/increase/types/check_deposit.py | 7 +- src/increase/types/inbound_mail_item.py | 28 +- .../types/inbound_mail_item_list_params.py | 7 +- src/increase/types/lockbox.py | 107 ---- src/increase/types/lockbox_address.py | 81 +++ .../types/lockbox_address_create_params.py | 12 + ...rams.py => lockbox_address_list_params.py} | 7 +- .../types/lockbox_address_update_params.py | 20 + src/increase/types/lockbox_create_params.py | 18 - src/increase/types/lockbox_recipient.py | 74 +++ .../types/lockbox_recipient_create_params.py | 23 + .../types/lockbox_recipient_list_params.py | 66 ++ .../types/lockbox_recipient_update_params.py | 25 + src/increase/types/lockbox_update_params.py | 24 - .../inbound_mail_item_create_params.py | 9 +- .../simulations/test_inbound_mail_items.py | 12 +- .../api_resources/test_inbound_mail_items.py | 6 +- tests/api_resources/test_lockbox_addresses.py | 342 ++++++++++ ...ockboxes.py => test_lockbox_recipients.py} | 218 ++++--- 28 files changed, 1661 insertions(+), 498 deletions(-) rename src/increase/resources/{lockboxes.py => lockbox_addresses.py} (68%) create mode 100644 src/increase/resources/lockbox_recipients.py delete mode 100644 src/increase/types/lockbox.py create mode 100644 src/increase/types/lockbox_address.py create mode 100644 src/increase/types/lockbox_address_create_params.py rename src/increase/types/{lockbox_list_params.py => lockbox_address_list_params.py} (89%) create mode 100644 src/increase/types/lockbox_address_update_params.py delete mode 100644 src/increase/types/lockbox_create_params.py create mode 100644 src/increase/types/lockbox_recipient.py create mode 100644 src/increase/types/lockbox_recipient_create_params.py create mode 100644 src/increase/types/lockbox_recipient_list_params.py create mode 100644 src/increase/types/lockbox_recipient_update_params.py delete mode 100644 src/increase/types/lockbox_update_params.py create mode 100644 tests/api_resources/test_lockbox_addresses.py rename tests/api_resources/{test_lockboxes.py => test_lockbox_recipients.py} (53%) diff --git a/.stats.yml b/.stats.yml index 2c0b26927..0f4697e38 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ -configured_endpoints: 232 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/increase%2Fincrease-0482ee5f9cf2cd09691221500b562dab1092df43e774e92b714ccebebf618b1b.yml -openapi_spec_hash: 3f1b98e772d86cca81fa3186198a6937 -config_hash: b24ba63471a818520cec39b4695e1825 +configured_endpoints: 236 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/increase%2Fincrease-47752267c48d299a01c906499bb7d584228ea8801b7d83e34ae4100d5dec3434.yml +openapi_spec_hash: 132e71b6e6bb1c5f06153f87d50e335b +config_hash: 026e2baa580c7f5f2447c24332081ba8 diff --git a/api.md b/api.md index 91af5ff3c..7f0e4d648 100644 --- a/api.md +++ b/api.md @@ -430,20 +430,35 @@ Methods: - client.check_deposits.retrieve(check_deposit_id) -> CheckDeposit - client.check_deposits.list(\*\*params) -> SyncPage[CheckDeposit] -# Lockboxes +# LockboxAddresses Types: ```python -from increase.types import Lockbox +from increase.types import LockboxAddress ``` Methods: -- client.lockboxes.create(\*\*params) -> Lockbox -- client.lockboxes.retrieve(lockbox_id) -> Lockbox -- client.lockboxes.update(lockbox_id, \*\*params) -> Lockbox -- client.lockboxes.list(\*\*params) -> SyncPage[Lockbox] +- client.lockbox_addresses.create(\*\*params) -> LockboxAddress +- client.lockbox_addresses.retrieve(lockbox_address_id) -> LockboxAddress +- client.lockbox_addresses.update(lockbox_address_id, \*\*params) -> LockboxAddress +- client.lockbox_addresses.list(\*\*params) -> SyncPage[LockboxAddress] + +# LockboxRecipients + +Types: + +```python +from increase.types import LockboxRecipient +``` + +Methods: + +- client.lockbox_recipients.create(\*\*params) -> LockboxRecipient +- client.lockbox_recipients.retrieve(lockbox_recipient_id) -> LockboxRecipient +- client.lockbox_recipients.update(lockbox_recipient_id, \*\*params) -> LockboxRecipient +- client.lockbox_recipients.list(\*\*params) -> SyncPage[LockboxRecipient] # InboundMailItems diff --git a/src/increase/_client.py b/src/increase/_client.py index 9f62f8538..899a105a3 100644 --- a/src/increase/_client.py +++ b/src/increase/_client.py @@ -44,7 +44,6 @@ accounts, entities, programs, - lockboxes, file_links, card_tokens, simulations, @@ -66,10 +65,12 @@ account_transfers, beneficial_owners, external_accounts, + lockbox_addresses, oauth_connections, account_statements, inbound_mail_items, intrafi_exclusions, + lockbox_recipients, oauth_applications, card_push_transfers, event_subscriptions, @@ -101,7 +102,6 @@ from .resources.accounts import AccountsResource, AsyncAccountsResource from .resources.entities import EntitiesResource, AsyncEntitiesResource from .resources.programs import ProgramsResource, AsyncProgramsResource - from .resources.lockboxes import LockboxesResource, AsyncLockboxesResource from .resources.file_links import FileLinksResource, AsyncFileLinksResource from .resources.card_tokens import CardTokensResource, AsyncCardTokensResource from .resources.oauth_tokens import OAuthTokensResource, AsyncOAuthTokensResource @@ -122,10 +122,12 @@ from .resources.account_transfers import AccountTransfersResource, AsyncAccountTransfersResource from .resources.beneficial_owners import BeneficialOwnersResource, AsyncBeneficialOwnersResource from .resources.external_accounts import ExternalAccountsResource, AsyncExternalAccountsResource + from .resources.lockbox_addresses import LockboxAddressesResource, AsyncLockboxAddressesResource from .resources.oauth_connections import OAuthConnectionsResource, AsyncOAuthConnectionsResource from .resources.account_statements import AccountStatementsResource, AsyncAccountStatementsResource from .resources.inbound_mail_items import InboundMailItemsResource, AsyncInboundMailItemsResource from .resources.intrafi_exclusions import IntrafiExclusionsResource, AsyncIntrafiExclusionsResource + from .resources.lockbox_recipients import LockboxRecipientsResource, AsyncLockboxRecipientsResource from .resources.oauth_applications import OAuthApplicationsResource, AsyncOAuthApplicationsResource from .resources.card_push_transfers import CardPushTransfersResource, AsyncCardPushTransfersResource from .resources.event_subscriptions import EventSubscriptionsResource, AsyncEventSubscriptionsResource @@ -450,10 +452,16 @@ def check_deposits(self) -> CheckDepositsResource: return CheckDepositsResource(self) @cached_property - def lockboxes(self) -> LockboxesResource: - from .resources.lockboxes import LockboxesResource + def lockbox_addresses(self) -> LockboxAddressesResource: + from .resources.lockbox_addresses import LockboxAddressesResource - return LockboxesResource(self) + return LockboxAddressesResource(self) + + @cached_property + def lockbox_recipients(self) -> LockboxRecipientsResource: + from .resources.lockbox_recipients import LockboxRecipientsResource + + return LockboxRecipientsResource(self) @cached_property def inbound_mail_items(self) -> InboundMailItemsResource: @@ -1037,10 +1045,16 @@ def check_deposits(self) -> AsyncCheckDepositsResource: return AsyncCheckDepositsResource(self) @cached_property - def lockboxes(self) -> AsyncLockboxesResource: - from .resources.lockboxes import AsyncLockboxesResource + def lockbox_addresses(self) -> AsyncLockboxAddressesResource: + from .resources.lockbox_addresses import AsyncLockboxAddressesResource - return AsyncLockboxesResource(self) + return AsyncLockboxAddressesResource(self) + + @cached_property + def lockbox_recipients(self) -> AsyncLockboxRecipientsResource: + from .resources.lockbox_recipients import AsyncLockboxRecipientsResource + + return AsyncLockboxRecipientsResource(self) @cached_property def inbound_mail_items(self) -> AsyncInboundMailItemsResource: @@ -1551,10 +1565,16 @@ def check_deposits(self) -> check_deposits.CheckDepositsResourceWithRawResponse: return CheckDepositsResourceWithRawResponse(self._client.check_deposits) @cached_property - def lockboxes(self) -> lockboxes.LockboxesResourceWithRawResponse: - from .resources.lockboxes import LockboxesResourceWithRawResponse + def lockbox_addresses(self) -> lockbox_addresses.LockboxAddressesResourceWithRawResponse: + from .resources.lockbox_addresses import LockboxAddressesResourceWithRawResponse + + return LockboxAddressesResourceWithRawResponse(self._client.lockbox_addresses) + + @cached_property + def lockbox_recipients(self) -> lockbox_recipients.LockboxRecipientsResourceWithRawResponse: + from .resources.lockbox_recipients import LockboxRecipientsResourceWithRawResponse - return LockboxesResourceWithRawResponse(self._client.lockboxes) + return LockboxRecipientsResourceWithRawResponse(self._client.lockbox_recipients) @cached_property def inbound_mail_items(self) -> inbound_mail_items.InboundMailItemsResourceWithRawResponse: @@ -1908,10 +1928,16 @@ def check_deposits(self) -> check_deposits.AsyncCheckDepositsResourceWithRawResp return AsyncCheckDepositsResourceWithRawResponse(self._client.check_deposits) @cached_property - def lockboxes(self) -> lockboxes.AsyncLockboxesResourceWithRawResponse: - from .resources.lockboxes import AsyncLockboxesResourceWithRawResponse + def lockbox_addresses(self) -> lockbox_addresses.AsyncLockboxAddressesResourceWithRawResponse: + from .resources.lockbox_addresses import AsyncLockboxAddressesResourceWithRawResponse - return AsyncLockboxesResourceWithRawResponse(self._client.lockboxes) + return AsyncLockboxAddressesResourceWithRawResponse(self._client.lockbox_addresses) + + @cached_property + def lockbox_recipients(self) -> lockbox_recipients.AsyncLockboxRecipientsResourceWithRawResponse: + from .resources.lockbox_recipients import AsyncLockboxRecipientsResourceWithRawResponse + + return AsyncLockboxRecipientsResourceWithRawResponse(self._client.lockbox_recipients) @cached_property def inbound_mail_items(self) -> inbound_mail_items.AsyncInboundMailItemsResourceWithRawResponse: @@ -2267,10 +2293,16 @@ def check_deposits(self) -> check_deposits.CheckDepositsResourceWithStreamingRes return CheckDepositsResourceWithStreamingResponse(self._client.check_deposits) @cached_property - def lockboxes(self) -> lockboxes.LockboxesResourceWithStreamingResponse: - from .resources.lockboxes import LockboxesResourceWithStreamingResponse + def lockbox_addresses(self) -> lockbox_addresses.LockboxAddressesResourceWithStreamingResponse: + from .resources.lockbox_addresses import LockboxAddressesResourceWithStreamingResponse - return LockboxesResourceWithStreamingResponse(self._client.lockboxes) + return LockboxAddressesResourceWithStreamingResponse(self._client.lockbox_addresses) + + @cached_property + def lockbox_recipients(self) -> lockbox_recipients.LockboxRecipientsResourceWithStreamingResponse: + from .resources.lockbox_recipients import LockboxRecipientsResourceWithStreamingResponse + + return LockboxRecipientsResourceWithStreamingResponse(self._client.lockbox_recipients) @cached_property def inbound_mail_items(self) -> inbound_mail_items.InboundMailItemsResourceWithStreamingResponse: @@ -2632,10 +2664,16 @@ def check_deposits(self) -> check_deposits.AsyncCheckDepositsResourceWithStreami return AsyncCheckDepositsResourceWithStreamingResponse(self._client.check_deposits) @cached_property - def lockboxes(self) -> lockboxes.AsyncLockboxesResourceWithStreamingResponse: - from .resources.lockboxes import AsyncLockboxesResourceWithStreamingResponse + def lockbox_addresses(self) -> lockbox_addresses.AsyncLockboxAddressesResourceWithStreamingResponse: + from .resources.lockbox_addresses import AsyncLockboxAddressesResourceWithStreamingResponse + + return AsyncLockboxAddressesResourceWithStreamingResponse(self._client.lockbox_addresses) + + @cached_property + def lockbox_recipients(self) -> lockbox_recipients.AsyncLockboxRecipientsResourceWithStreamingResponse: + from .resources.lockbox_recipients import AsyncLockboxRecipientsResourceWithStreamingResponse - return AsyncLockboxesResourceWithStreamingResponse(self._client.lockboxes) + return AsyncLockboxRecipientsResourceWithStreamingResponse(self._client.lockbox_recipients) @cached_property def inbound_mail_items(self) -> inbound_mail_items.AsyncInboundMailItemsResourceWithStreamingResponse: diff --git a/src/increase/resources/__init__.py b/src/increase/resources/__init__.py index 0e6da752e..d54fafea2 100644 --- a/src/increase/resources/__init__.py +++ b/src/increase/resources/__init__.py @@ -64,14 +64,6 @@ ProgramsResourceWithStreamingResponse, AsyncProgramsResourceWithStreamingResponse, ) -from .lockboxes import ( - LockboxesResource, - AsyncLockboxesResource, - LockboxesResourceWithRawResponse, - AsyncLockboxesResourceWithRawResponse, - LockboxesResourceWithStreamingResponse, - AsyncLockboxesResourceWithStreamingResponse, -) from .file_links import ( FileLinksResource, AsyncFileLinksResource, @@ -240,6 +232,14 @@ ExternalAccountsResourceWithStreamingResponse, AsyncExternalAccountsResourceWithStreamingResponse, ) +from .lockbox_addresses import ( + LockboxAddressesResource, + AsyncLockboxAddressesResource, + LockboxAddressesResourceWithRawResponse, + AsyncLockboxAddressesResourceWithRawResponse, + LockboxAddressesResourceWithStreamingResponse, + AsyncLockboxAddressesResourceWithStreamingResponse, +) from .oauth_connections import ( OAuthConnectionsResource, AsyncOAuthConnectionsResource, @@ -272,6 +272,14 @@ IntrafiExclusionsResourceWithStreamingResponse, AsyncIntrafiExclusionsResourceWithStreamingResponse, ) +from .lockbox_recipients import ( + LockboxRecipientsResource, + AsyncLockboxRecipientsResource, + LockboxRecipientsResourceWithRawResponse, + AsyncLockboxRecipientsResourceWithRawResponse, + LockboxRecipientsResourceWithStreamingResponse, + AsyncLockboxRecipientsResourceWithStreamingResponse, +) from .oauth_applications import ( OAuthApplicationsResource, AsyncOAuthApplicationsResource, @@ -624,12 +632,18 @@ "AsyncCheckDepositsResourceWithRawResponse", "CheckDepositsResourceWithStreamingResponse", "AsyncCheckDepositsResourceWithStreamingResponse", - "LockboxesResource", - "AsyncLockboxesResource", - "LockboxesResourceWithRawResponse", - "AsyncLockboxesResourceWithRawResponse", - "LockboxesResourceWithStreamingResponse", - "AsyncLockboxesResourceWithStreamingResponse", + "LockboxAddressesResource", + "AsyncLockboxAddressesResource", + "LockboxAddressesResourceWithRawResponse", + "AsyncLockboxAddressesResourceWithRawResponse", + "LockboxAddressesResourceWithStreamingResponse", + "AsyncLockboxAddressesResourceWithStreamingResponse", + "LockboxRecipientsResource", + "AsyncLockboxRecipientsResource", + "LockboxRecipientsResourceWithRawResponse", + "AsyncLockboxRecipientsResourceWithRawResponse", + "LockboxRecipientsResourceWithStreamingResponse", + "AsyncLockboxRecipientsResourceWithStreamingResponse", "InboundMailItemsResource", "AsyncInboundMailItemsResource", "InboundMailItemsResourceWithRawResponse", diff --git a/src/increase/resources/inbound_mail_items.py b/src/increase/resources/inbound_mail_items.py index 8af4e7791..8945dc2c8 100644 --- a/src/increase/resources/inbound_mail_items.py +++ b/src/increase/resources/inbound_mail_items.py @@ -87,7 +87,8 @@ def list( created_at: inbound_mail_item_list_params.CreatedAt | Omit = omit, cursor: str | Omit = omit, limit: int | Omit = omit, - lockbox_id: str | Omit = omit, + lockbox_address_id: str | Omit = omit, + lockbox_recipient_id: 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, @@ -104,7 +105,9 @@ def list( limit: Limit the size of the list that is returned. The default (and maximum) is 100 objects. - lockbox_id: Filter Inbound Mail Items to ones sent to the provided Lockbox. + lockbox_address_id: Filter Inbound Mail Items to ones sent to the provided Lockbox Address. + + lockbox_recipient_id: Filter Inbound Mail Items to ones sent to the provided Lockbox Recipient. extra_headers: Send extra headers @@ -127,7 +130,8 @@ def list( "created_at": created_at, "cursor": cursor, "limit": limit, - "lockbox_id": lockbox_id, + "lockbox_address_id": lockbox_address_id, + "lockbox_recipient_id": lockbox_recipient_id, }, inbound_mail_item_list_params.InboundMailItemListParams, ), @@ -249,7 +253,8 @@ def list( created_at: inbound_mail_item_list_params.CreatedAt | Omit = omit, cursor: str | Omit = omit, limit: int | Omit = omit, - lockbox_id: str | Omit = omit, + lockbox_address_id: str | Omit = omit, + lockbox_recipient_id: 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, @@ -266,7 +271,9 @@ def list( limit: Limit the size of the list that is returned. The default (and maximum) is 100 objects. - lockbox_id: Filter Inbound Mail Items to ones sent to the provided Lockbox. + lockbox_address_id: Filter Inbound Mail Items to ones sent to the provided Lockbox Address. + + lockbox_recipient_id: Filter Inbound Mail Items to ones sent to the provided Lockbox Recipient. extra_headers: Send extra headers @@ -289,7 +296,8 @@ def list( "created_at": created_at, "cursor": cursor, "limit": limit, - "lockbox_id": lockbox_id, + "lockbox_address_id": lockbox_address_id, + "lockbox_recipient_id": lockbox_recipient_id, }, inbound_mail_item_list_params.InboundMailItemListParams, ), diff --git a/src/increase/resources/lockboxes.py b/src/increase/resources/lockbox_addresses.py similarity index 68% rename from src/increase/resources/lockboxes.py rename to src/increase/resources/lockbox_addresses.py index b06fb0e1e..5023d38f8 100644 --- a/src/increase/resources/lockboxes.py +++ b/src/increase/resources/lockbox_addresses.py @@ -6,7 +6,7 @@ import httpx -from ..types import lockbox_list_params, lockbox_create_params, lockbox_update_params +from ..types import lockbox_address_list_params, lockbox_address_create_params, lockbox_address_update_params from .._types import Body, Omit, Query, Headers, NotGiven, omit, not_given from .._utils import path_template, maybe_transform, async_maybe_transform from .._compat import cached_property @@ -19,37 +19,35 @@ ) from ..pagination import SyncPage, AsyncPage from .._base_client import AsyncPaginator, make_request_options -from ..types.lockbox import Lockbox +from ..types.lockbox_address import LockboxAddress -__all__ = ["LockboxesResource", "AsyncLockboxesResource"] +__all__ = ["LockboxAddressesResource", "AsyncLockboxAddressesResource"] -class LockboxesResource(SyncAPIResource): +class LockboxAddressesResource(SyncAPIResource): @cached_property - def with_raw_response(self) -> LockboxesResourceWithRawResponse: + def with_raw_response(self) -> LockboxAddressesResourceWithRawResponse: """ 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/Increase/increase-python#accessing-raw-response-data-eg-headers """ - return LockboxesResourceWithRawResponse(self) + return LockboxAddressesResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> LockboxesResourceWithStreamingResponse: + def with_streaming_response(self) -> LockboxAddressesResourceWithStreamingResponse: """ An alternative to `.with_raw_response` that doesn't eagerly read the response body. For more information, see https://www.github.com/Increase/increase-python#with_streaming_response """ - return LockboxesResourceWithStreamingResponse(self) + return LockboxAddressesResourceWithStreamingResponse(self) def create( self, *, - account_id: str, description: str | Omit = omit, - recipient_name: 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, @@ -57,16 +55,12 @@ def create( extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = not_given, idempotency_key: str | None = None, - ) -> Lockbox: + ) -> LockboxAddress: """ - Create a Lockbox + Create a Lockbox Address Args: - account_id: The Account checks sent to this Lockbox should be deposited into. - - description: The description you choose for the Lockbox, for display purposes. - - recipient_name: The name of the recipient that will receive mail at this location. + description: The description you choose for the Lockbox Address. extra_headers: Send extra headers @@ -79,14 +73,9 @@ def create( idempotency_key: Specify a custom idempotency key for this request """ return self._post( - "/lockboxes", + "/lockbox_addresses", body=maybe_transform( - { - "account_id": account_id, - "description": description, - "recipient_name": recipient_name, - }, - lockbox_create_params.LockboxCreateParams, + {"description": description}, lockbox_address_create_params.LockboxAddressCreateParams ), options=make_request_options( extra_headers=extra_headers, @@ -95,12 +84,12 @@ def create( timeout=timeout, idempotency_key=idempotency_key, ), - cast_to=Lockbox, + cast_to=LockboxAddress, ) def retrieve( self, - lockbox_id: str, + lockbox_address_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. @@ -108,12 +97,12 @@ def retrieve( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = not_given, - ) -> Lockbox: + ) -> LockboxAddress: """ - Retrieve a Lockbox + Retrieve a Lockbox Address Args: - lockbox_id: The identifier of the Lockbox to retrieve. + lockbox_address_id: The identifier of the Lockbox Address to retrieve. extra_headers: Send extra headers @@ -123,23 +112,22 @@ def retrieve( timeout: Override the client-level default timeout for this request, in seconds """ - if not lockbox_id: - raise ValueError(f"Expected a non-empty value for `lockbox_id` but received {lockbox_id!r}") + if not lockbox_address_id: + raise ValueError(f"Expected a non-empty value for `lockbox_address_id` but received {lockbox_address_id!r}") return self._get( - path_template("/lockboxes/{lockbox_id}", lockbox_id=lockbox_id), + path_template("/lockbox_addresses/{lockbox_address_id}", lockbox_address_id=lockbox_address_id), options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=Lockbox, + cast_to=LockboxAddress, ) def update( self, - lockbox_id: str, + lockbox_address_id: str, *, - check_deposit_behavior: Literal["enabled", "disabled", "pend_for_processing"] | Omit = omit, description: str | Omit = omit, - recipient_name: str | Omit = omit, + status: Literal["active", "disabled", "canceled"] | 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, @@ -147,23 +135,20 @@ def update( extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = not_given, idempotency_key: str | None = None, - ) -> Lockbox: + ) -> LockboxAddress: """ - Update a Lockbox + Update a Lockbox Address Args: - lockbox_id: The identifier of the Lockbox. - - check_deposit_behavior: This indicates if checks mailed to this lockbox will be deposited. + lockbox_address_id: The identifier of the Lockbox Address. - - `enabled` - Checks mailed to this Lockbox will be deposited. - - `disabled` - Checks mailed to this Lockbox will not be deposited. - - `pend_for_processing` - Checks mailed to this Lockbox will be pending until - actioned. + description: The description you choose for the Lockbox Address. - description: The description you choose for the Lockbox. + status: The status of the Lockbox Address. - recipient_name: The recipient name you choose for the Lockbox. + - `active` - This Lockbox Address is active. + - `disabled` - This Lockbox Address is disabled. + - `canceled` - This Lockbox Address is permanently disabled. extra_headers: Send extra headers @@ -175,17 +160,16 @@ def update( idempotency_key: Specify a custom idempotency key for this request """ - if not lockbox_id: - raise ValueError(f"Expected a non-empty value for `lockbox_id` but received {lockbox_id!r}") + if not lockbox_address_id: + raise ValueError(f"Expected a non-empty value for `lockbox_address_id` but received {lockbox_address_id!r}") return self._patch( - path_template("/lockboxes/{lockbox_id}", lockbox_id=lockbox_id), + path_template("/lockbox_addresses/{lockbox_address_id}", lockbox_address_id=lockbox_address_id), body=maybe_transform( { - "check_deposit_behavior": check_deposit_behavior, "description": description, - "recipient_name": recipient_name, + "status": status, }, - lockbox_update_params.LockboxUpdateParams, + lockbox_address_update_params.LockboxAddressUpdateParams, ), options=make_request_options( extra_headers=extra_headers, @@ -194,14 +178,13 @@ def update( timeout=timeout, idempotency_key=idempotency_key, ), - cast_to=Lockbox, + cast_to=LockboxAddress, ) def list( self, *, - account_id: str | Omit = omit, - created_at: lockbox_list_params.CreatedAt | Omit = omit, + created_at: lockbox_address_list_params.CreatedAt | Omit = omit, cursor: str | Omit = omit, idempotency_key: str | Omit = omit, limit: int | Omit = omit, @@ -211,13 +194,11 @@ def list( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = not_given, - ) -> SyncPage[Lockbox]: + ) -> SyncPage[LockboxAddress]: """ - List Lockboxes + List Lockbox Addresses Args: - account_id: Filter Lockboxes to those associated with the provided Account. - cursor: Return the page of entries after this one. idempotency_key: Filter records to the one with the specified `idempotency_key` you chose for @@ -237,8 +218,8 @@ def list( timeout: Override the client-level default timeout for this request, in seconds """ return self._get_api_list( - "/lockboxes", - page=SyncPage[Lockbox], + "/lockbox_addresses", + page=SyncPage[LockboxAddress], options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, @@ -246,45 +227,42 @@ def list( timeout=timeout, query=maybe_transform( { - "account_id": account_id, "created_at": created_at, "cursor": cursor, "idempotency_key": idempotency_key, "limit": limit, }, - lockbox_list_params.LockboxListParams, + lockbox_address_list_params.LockboxAddressListParams, ), ), - model=Lockbox, + model=LockboxAddress, ) -class AsyncLockboxesResource(AsyncAPIResource): +class AsyncLockboxAddressesResource(AsyncAPIResource): @cached_property - def with_raw_response(self) -> AsyncLockboxesResourceWithRawResponse: + def with_raw_response(self) -> AsyncLockboxAddressesResourceWithRawResponse: """ 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/Increase/increase-python#accessing-raw-response-data-eg-headers """ - return AsyncLockboxesResourceWithRawResponse(self) + return AsyncLockboxAddressesResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> AsyncLockboxesResourceWithStreamingResponse: + def with_streaming_response(self) -> AsyncLockboxAddressesResourceWithStreamingResponse: """ An alternative to `.with_raw_response` that doesn't eagerly read the response body. For more information, see https://www.github.com/Increase/increase-python#with_streaming_response """ - return AsyncLockboxesResourceWithStreamingResponse(self) + return AsyncLockboxAddressesResourceWithStreamingResponse(self) async def create( self, *, - account_id: str, description: str | Omit = omit, - recipient_name: 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, @@ -292,16 +270,12 @@ async def create( extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = not_given, idempotency_key: str | None = None, - ) -> Lockbox: + ) -> LockboxAddress: """ - Create a Lockbox + Create a Lockbox Address Args: - account_id: The Account checks sent to this Lockbox should be deposited into. - - description: The description you choose for the Lockbox, for display purposes. - - recipient_name: The name of the recipient that will receive mail at this location. + description: The description you choose for the Lockbox Address. extra_headers: Send extra headers @@ -314,14 +288,9 @@ async def create( idempotency_key: Specify a custom idempotency key for this request """ return await self._post( - "/lockboxes", + "/lockbox_addresses", body=await async_maybe_transform( - { - "account_id": account_id, - "description": description, - "recipient_name": recipient_name, - }, - lockbox_create_params.LockboxCreateParams, + {"description": description}, lockbox_address_create_params.LockboxAddressCreateParams ), options=make_request_options( extra_headers=extra_headers, @@ -330,12 +299,12 @@ async def create( timeout=timeout, idempotency_key=idempotency_key, ), - cast_to=Lockbox, + cast_to=LockboxAddress, ) async def retrieve( self, - lockbox_id: str, + lockbox_address_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. @@ -343,12 +312,12 @@ async def retrieve( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = not_given, - ) -> Lockbox: + ) -> LockboxAddress: """ - Retrieve a Lockbox + Retrieve a Lockbox Address Args: - lockbox_id: The identifier of the Lockbox to retrieve. + lockbox_address_id: The identifier of the Lockbox Address to retrieve. extra_headers: Send extra headers @@ -358,23 +327,22 @@ async def retrieve( timeout: Override the client-level default timeout for this request, in seconds """ - if not lockbox_id: - raise ValueError(f"Expected a non-empty value for `lockbox_id` but received {lockbox_id!r}") + if not lockbox_address_id: + raise ValueError(f"Expected a non-empty value for `lockbox_address_id` but received {lockbox_address_id!r}") return await self._get( - path_template("/lockboxes/{lockbox_id}", lockbox_id=lockbox_id), + path_template("/lockbox_addresses/{lockbox_address_id}", lockbox_address_id=lockbox_address_id), options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), - cast_to=Lockbox, + cast_to=LockboxAddress, ) async def update( self, - lockbox_id: str, + lockbox_address_id: str, *, - check_deposit_behavior: Literal["enabled", "disabled", "pend_for_processing"] | Omit = omit, description: str | Omit = omit, - recipient_name: str | Omit = omit, + status: Literal["active", "disabled", "canceled"] | 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, @@ -382,23 +350,20 @@ async def update( extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = not_given, idempotency_key: str | None = None, - ) -> Lockbox: + ) -> LockboxAddress: """ - Update a Lockbox + Update a Lockbox Address Args: - lockbox_id: The identifier of the Lockbox. - - check_deposit_behavior: This indicates if checks mailed to this lockbox will be deposited. + lockbox_address_id: The identifier of the Lockbox Address. - - `enabled` - Checks mailed to this Lockbox will be deposited. - - `disabled` - Checks mailed to this Lockbox will not be deposited. - - `pend_for_processing` - Checks mailed to this Lockbox will be pending until - actioned. + description: The description you choose for the Lockbox Address. - description: The description you choose for the Lockbox. + status: The status of the Lockbox Address. - recipient_name: The recipient name you choose for the Lockbox. + - `active` - This Lockbox Address is active. + - `disabled` - This Lockbox Address is disabled. + - `canceled` - This Lockbox Address is permanently disabled. extra_headers: Send extra headers @@ -410,17 +375,16 @@ async def update( idempotency_key: Specify a custom idempotency key for this request """ - if not lockbox_id: - raise ValueError(f"Expected a non-empty value for `lockbox_id` but received {lockbox_id!r}") + if not lockbox_address_id: + raise ValueError(f"Expected a non-empty value for `lockbox_address_id` but received {lockbox_address_id!r}") return await self._patch( - path_template("/lockboxes/{lockbox_id}", lockbox_id=lockbox_id), + path_template("/lockbox_addresses/{lockbox_address_id}", lockbox_address_id=lockbox_address_id), body=await async_maybe_transform( { - "check_deposit_behavior": check_deposit_behavior, "description": description, - "recipient_name": recipient_name, + "status": status, }, - lockbox_update_params.LockboxUpdateParams, + lockbox_address_update_params.LockboxAddressUpdateParams, ), options=make_request_options( extra_headers=extra_headers, @@ -429,14 +393,13 @@ async def update( timeout=timeout, idempotency_key=idempotency_key, ), - cast_to=Lockbox, + cast_to=LockboxAddress, ) def list( self, *, - account_id: str | Omit = omit, - created_at: lockbox_list_params.CreatedAt | Omit = omit, + created_at: lockbox_address_list_params.CreatedAt | Omit = omit, cursor: str | Omit = omit, idempotency_key: str | Omit = omit, limit: int | Omit = omit, @@ -446,13 +409,11 @@ def list( extra_query: Query | None = None, extra_body: Body | None = None, timeout: float | httpx.Timeout | None | NotGiven = not_given, - ) -> AsyncPaginator[Lockbox, AsyncPage[Lockbox]]: + ) -> AsyncPaginator[LockboxAddress, AsyncPage[LockboxAddress]]: """ - List Lockboxes + List Lockbox Addresses Args: - account_id: Filter Lockboxes to those associated with the provided Account. - cursor: Return the page of entries after this one. idempotency_key: Filter records to the one with the specified `idempotency_key` you chose for @@ -472,8 +433,8 @@ def list( timeout: Override the client-level default timeout for this request, in seconds """ return self._get_api_list( - "/lockboxes", - page=AsyncPage[Lockbox], + "/lockbox_addresses", + page=AsyncPage[LockboxAddress], options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, @@ -481,86 +442,85 @@ def list( timeout=timeout, query=maybe_transform( { - "account_id": account_id, "created_at": created_at, "cursor": cursor, "idempotency_key": idempotency_key, "limit": limit, }, - lockbox_list_params.LockboxListParams, + lockbox_address_list_params.LockboxAddressListParams, ), ), - model=Lockbox, + model=LockboxAddress, ) -class LockboxesResourceWithRawResponse: - def __init__(self, lockboxes: LockboxesResource) -> None: - self._lockboxes = lockboxes +class LockboxAddressesResourceWithRawResponse: + def __init__(self, lockbox_addresses: LockboxAddressesResource) -> None: + self._lockbox_addresses = lockbox_addresses self.create = to_raw_response_wrapper( - lockboxes.create, + lockbox_addresses.create, ) self.retrieve = to_raw_response_wrapper( - lockboxes.retrieve, + lockbox_addresses.retrieve, ) self.update = to_raw_response_wrapper( - lockboxes.update, + lockbox_addresses.update, ) self.list = to_raw_response_wrapper( - lockboxes.list, + lockbox_addresses.list, ) -class AsyncLockboxesResourceWithRawResponse: - def __init__(self, lockboxes: AsyncLockboxesResource) -> None: - self._lockboxes = lockboxes +class AsyncLockboxAddressesResourceWithRawResponse: + def __init__(self, lockbox_addresses: AsyncLockboxAddressesResource) -> None: + self._lockbox_addresses = lockbox_addresses self.create = async_to_raw_response_wrapper( - lockboxes.create, + lockbox_addresses.create, ) self.retrieve = async_to_raw_response_wrapper( - lockboxes.retrieve, + lockbox_addresses.retrieve, ) self.update = async_to_raw_response_wrapper( - lockboxes.update, + lockbox_addresses.update, ) self.list = async_to_raw_response_wrapper( - lockboxes.list, + lockbox_addresses.list, ) -class LockboxesResourceWithStreamingResponse: - def __init__(self, lockboxes: LockboxesResource) -> None: - self._lockboxes = lockboxes +class LockboxAddressesResourceWithStreamingResponse: + def __init__(self, lockbox_addresses: LockboxAddressesResource) -> None: + self._lockbox_addresses = lockbox_addresses self.create = to_streamed_response_wrapper( - lockboxes.create, + lockbox_addresses.create, ) self.retrieve = to_streamed_response_wrapper( - lockboxes.retrieve, + lockbox_addresses.retrieve, ) self.update = to_streamed_response_wrapper( - lockboxes.update, + lockbox_addresses.update, ) self.list = to_streamed_response_wrapper( - lockboxes.list, + lockbox_addresses.list, ) -class AsyncLockboxesResourceWithStreamingResponse: - def __init__(self, lockboxes: AsyncLockboxesResource) -> None: - self._lockboxes = lockboxes +class AsyncLockboxAddressesResourceWithStreamingResponse: + def __init__(self, lockbox_addresses: AsyncLockboxAddressesResource) -> None: + self._lockbox_addresses = lockbox_addresses self.create = async_to_streamed_response_wrapper( - lockboxes.create, + lockbox_addresses.create, ) self.retrieve = async_to_streamed_response_wrapper( - lockboxes.retrieve, + lockbox_addresses.retrieve, ) self.update = async_to_streamed_response_wrapper( - lockboxes.update, + lockbox_addresses.update, ) self.list = async_to_streamed_response_wrapper( - lockboxes.list, + lockbox_addresses.list, ) diff --git a/src/increase/resources/lockbox_recipients.py b/src/increase/resources/lockbox_recipients.py new file mode 100644 index 000000000..4c816af11 --- /dev/null +++ b/src/increase/resources/lockbox_recipients.py @@ -0,0 +1,592 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing_extensions import Literal + +import httpx + +from ..types import lockbox_recipient_list_params, lockbox_recipient_create_params, lockbox_recipient_update_params +from .._types import Body, Omit, Query, Headers, NotGiven, omit, 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 ..pagination import SyncPage, AsyncPage +from .._base_client import AsyncPaginator, make_request_options +from ..types.lockbox_recipient import LockboxRecipient + +__all__ = ["LockboxRecipientsResource", "AsyncLockboxRecipientsResource"] + + +class LockboxRecipientsResource(SyncAPIResource): + @cached_property + def with_raw_response(self) -> LockboxRecipientsResourceWithRawResponse: + """ + 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/Increase/increase-python#accessing-raw-response-data-eg-headers + """ + return LockboxRecipientsResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> LockboxRecipientsResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/Increase/increase-python#with_streaming_response + """ + return LockboxRecipientsResourceWithStreamingResponse(self) + + def create( + self, + *, + account_id: str, + lockbox_address_id: str, + description: str | Omit = omit, + recipient_name: 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, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + idempotency_key: str | None = None, + ) -> LockboxRecipient: + """ + Create a Lockbox Recipient + + Args: + account_id: The Account that checks sent to this Lockbox Recipient should be deposited into. + + lockbox_address_id: The Lockbox Address where this Lockbox Recipient may receive mail. + + description: The description you choose for the Lockbox Recipient. + + recipient_name: The name of the Lockbox Recipient + + 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._post( + "/lockbox_recipients", + body=maybe_transform( + { + "account_id": account_id, + "lockbox_address_id": lockbox_address_id, + "description": description, + "recipient_name": recipient_name, + }, + lockbox_recipient_create_params.LockboxRecipientCreateParams, + ), + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + idempotency_key=idempotency_key, + ), + cast_to=LockboxRecipient, + ) + + def retrieve( + self, + lockbox_recipient_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, + ) -> LockboxRecipient: + """ + Retrieve a Lockbox Recipient + + Args: + lockbox_recipient_id: The identifier of the Lockbox Recipient to retrieve. + + 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 lockbox_recipient_id: + raise ValueError( + f"Expected a non-empty value for `lockbox_recipient_id` but received {lockbox_recipient_id!r}" + ) + return self._get( + path_template("/lockbox_recipients/{lockbox_recipient_id}", lockbox_recipient_id=lockbox_recipient_id), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=LockboxRecipient, + ) + + def update( + self, + lockbox_recipient_id: str, + *, + description: str | Omit = omit, + recipient_name: str | Omit = omit, + status: Literal["active", "disabled", "canceled"] | 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, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + idempotency_key: str | None = None, + ) -> LockboxRecipient: + """ + Update a Lockbox Recipient + + Args: + lockbox_recipient_id: The identifier of the Lockbox Recipient. + + description: The description you choose for the Lockbox Recipient. + + recipient_name: The name of the Lockbox Recipient. + + status: The status of the Lockbox Recipient. + + - `active` - This Lockbox Recipient is active. + - `disabled` - This Lockbox Recipient is disabled. Checks mailed to this Lockbox + Recipient will be rejected. + - `canceled` - This Lockbox Recipient is canceled and cannot be modified. Checks + mailed to this Lockbox Recipient will be rejected. + + 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 lockbox_recipient_id: + raise ValueError( + f"Expected a non-empty value for `lockbox_recipient_id` but received {lockbox_recipient_id!r}" + ) + return self._patch( + path_template("/lockbox_recipients/{lockbox_recipient_id}", lockbox_recipient_id=lockbox_recipient_id), + body=maybe_transform( + { + "description": description, + "recipient_name": recipient_name, + "status": status, + }, + lockbox_recipient_update_params.LockboxRecipientUpdateParams, + ), + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + idempotency_key=idempotency_key, + ), + cast_to=LockboxRecipient, + ) + + def list( + self, + *, + account_id: str | Omit = omit, + created_at: lockbox_recipient_list_params.CreatedAt | Omit = omit, + cursor: str | Omit = omit, + idempotency_key: str | Omit = omit, + limit: int | Omit = omit, + lockbox_address_id: 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, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> SyncPage[LockboxRecipient]: + """ + List Lockbox Recipients + + Args: + account_id: Filter Lockbox Recipients to those associated with the provided Account. + + cursor: Return the page of entries after this one. + + idempotency_key: Filter records to the one with the specified `idempotency_key` you chose for + that object. This value is unique across Increase and is used to ensure that a + request is only processed once. Learn more about + [idempotency](https://increase.com/documentation/idempotency-keys). + + limit: Limit the size of the list that is returned. The default (and maximum) is 100 + objects. + + lockbox_address_id: Filter Lockbox Recipients to those associated with the provided Lockbox Address. + + 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 + """ + return self._get_api_list( + "/lockbox_recipients", + page=SyncPage[LockboxRecipient], + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=maybe_transform( + { + "account_id": account_id, + "created_at": created_at, + "cursor": cursor, + "idempotency_key": idempotency_key, + "limit": limit, + "lockbox_address_id": lockbox_address_id, + }, + lockbox_recipient_list_params.LockboxRecipientListParams, + ), + ), + model=LockboxRecipient, + ) + + +class AsyncLockboxRecipientsResource(AsyncAPIResource): + @cached_property + def with_raw_response(self) -> AsyncLockboxRecipientsResourceWithRawResponse: + """ + 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/Increase/increase-python#accessing-raw-response-data-eg-headers + """ + return AsyncLockboxRecipientsResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncLockboxRecipientsResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/Increase/increase-python#with_streaming_response + """ + return AsyncLockboxRecipientsResourceWithStreamingResponse(self) + + async def create( + self, + *, + account_id: str, + lockbox_address_id: str, + description: str | Omit = omit, + recipient_name: 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, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + idempotency_key: str | None = None, + ) -> LockboxRecipient: + """ + Create a Lockbox Recipient + + Args: + account_id: The Account that checks sent to this Lockbox Recipient should be deposited into. + + lockbox_address_id: The Lockbox Address where this Lockbox Recipient may receive mail. + + description: The description you choose for the Lockbox Recipient. + + recipient_name: The name of the Lockbox Recipient + + 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._post( + "/lockbox_recipients", + body=await async_maybe_transform( + { + "account_id": account_id, + "lockbox_address_id": lockbox_address_id, + "description": description, + "recipient_name": recipient_name, + }, + lockbox_recipient_create_params.LockboxRecipientCreateParams, + ), + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + idempotency_key=idempotency_key, + ), + cast_to=LockboxRecipient, + ) + + async def retrieve( + self, + lockbox_recipient_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, + ) -> LockboxRecipient: + """ + Retrieve a Lockbox Recipient + + Args: + lockbox_recipient_id: The identifier of the Lockbox Recipient to retrieve. + + 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 lockbox_recipient_id: + raise ValueError( + f"Expected a non-empty value for `lockbox_recipient_id` but received {lockbox_recipient_id!r}" + ) + return await self._get( + path_template("/lockbox_recipients/{lockbox_recipient_id}", lockbox_recipient_id=lockbox_recipient_id), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=LockboxRecipient, + ) + + async def update( + self, + lockbox_recipient_id: str, + *, + description: str | Omit = omit, + recipient_name: str | Omit = omit, + status: Literal["active", "disabled", "canceled"] | 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, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + idempotency_key: str | None = None, + ) -> LockboxRecipient: + """ + Update a Lockbox Recipient + + Args: + lockbox_recipient_id: The identifier of the Lockbox Recipient. + + description: The description you choose for the Lockbox Recipient. + + recipient_name: The name of the Lockbox Recipient. + + status: The status of the Lockbox Recipient. + + - `active` - This Lockbox Recipient is active. + - `disabled` - This Lockbox Recipient is disabled. Checks mailed to this Lockbox + Recipient will be rejected. + - `canceled` - This Lockbox Recipient is canceled and cannot be modified. Checks + mailed to this Lockbox Recipient will be rejected. + + 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 lockbox_recipient_id: + raise ValueError( + f"Expected a non-empty value for `lockbox_recipient_id` but received {lockbox_recipient_id!r}" + ) + return await self._patch( + path_template("/lockbox_recipients/{lockbox_recipient_id}", lockbox_recipient_id=lockbox_recipient_id), + body=await async_maybe_transform( + { + "description": description, + "recipient_name": recipient_name, + "status": status, + }, + lockbox_recipient_update_params.LockboxRecipientUpdateParams, + ), + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + idempotency_key=idempotency_key, + ), + cast_to=LockboxRecipient, + ) + + def list( + self, + *, + account_id: str | Omit = omit, + created_at: lockbox_recipient_list_params.CreatedAt | Omit = omit, + cursor: str | Omit = omit, + idempotency_key: str | Omit = omit, + limit: int | Omit = omit, + lockbox_address_id: 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, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> AsyncPaginator[LockboxRecipient, AsyncPage[LockboxRecipient]]: + """ + List Lockbox Recipients + + Args: + account_id: Filter Lockbox Recipients to those associated with the provided Account. + + cursor: Return the page of entries after this one. + + idempotency_key: Filter records to the one with the specified `idempotency_key` you chose for + that object. This value is unique across Increase and is used to ensure that a + request is only processed once. Learn more about + [idempotency](https://increase.com/documentation/idempotency-keys). + + limit: Limit the size of the list that is returned. The default (and maximum) is 100 + objects. + + lockbox_address_id: Filter Lockbox Recipients to those associated with the provided Lockbox Address. + + 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 + """ + return self._get_api_list( + "/lockbox_recipients", + page=AsyncPage[LockboxRecipient], + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=maybe_transform( + { + "account_id": account_id, + "created_at": created_at, + "cursor": cursor, + "idempotency_key": idempotency_key, + "limit": limit, + "lockbox_address_id": lockbox_address_id, + }, + lockbox_recipient_list_params.LockboxRecipientListParams, + ), + ), + model=LockboxRecipient, + ) + + +class LockboxRecipientsResourceWithRawResponse: + def __init__(self, lockbox_recipients: LockboxRecipientsResource) -> None: + self._lockbox_recipients = lockbox_recipients + + self.create = to_raw_response_wrapper( + lockbox_recipients.create, + ) + self.retrieve = to_raw_response_wrapper( + lockbox_recipients.retrieve, + ) + self.update = to_raw_response_wrapper( + lockbox_recipients.update, + ) + self.list = to_raw_response_wrapper( + lockbox_recipients.list, + ) + + +class AsyncLockboxRecipientsResourceWithRawResponse: + def __init__(self, lockbox_recipients: AsyncLockboxRecipientsResource) -> None: + self._lockbox_recipients = lockbox_recipients + + self.create = async_to_raw_response_wrapper( + lockbox_recipients.create, + ) + self.retrieve = async_to_raw_response_wrapper( + lockbox_recipients.retrieve, + ) + self.update = async_to_raw_response_wrapper( + lockbox_recipients.update, + ) + self.list = async_to_raw_response_wrapper( + lockbox_recipients.list, + ) + + +class LockboxRecipientsResourceWithStreamingResponse: + def __init__(self, lockbox_recipients: LockboxRecipientsResource) -> None: + self._lockbox_recipients = lockbox_recipients + + self.create = to_streamed_response_wrapper( + lockbox_recipients.create, + ) + self.retrieve = to_streamed_response_wrapper( + lockbox_recipients.retrieve, + ) + self.update = to_streamed_response_wrapper( + lockbox_recipients.update, + ) + self.list = to_streamed_response_wrapper( + lockbox_recipients.list, + ) + + +class AsyncLockboxRecipientsResourceWithStreamingResponse: + def __init__(self, lockbox_recipients: AsyncLockboxRecipientsResource) -> None: + self._lockbox_recipients = lockbox_recipients + + self.create = async_to_streamed_response_wrapper( + lockbox_recipients.create, + ) + self.retrieve = async_to_streamed_response_wrapper( + lockbox_recipients.retrieve, + ) + self.update = async_to_streamed_response_wrapper( + lockbox_recipients.update, + ) + self.list = async_to_streamed_response_wrapper( + lockbox_recipients.list, + ) diff --git a/src/increase/resources/simulations/inbound_mail_items.py b/src/increase/resources/simulations/inbound_mail_items.py index 3439589af..391028eac 100755 --- a/src/increase/resources/simulations/inbound_mail_items.py +++ b/src/increase/resources/simulations/inbound_mail_items.py @@ -45,8 +45,9 @@ def create( self, *, amount: int, - lockbox_id: str, contents_file_id: str | Omit = omit, + lockbox_address_id: str | Omit = omit, + lockbox_recipient_id: 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, @@ -62,11 +63,13 @@ def create( Args: amount: The amount of the check to be simulated, in cents. - lockbox_id: The identifier of the Lockbox to simulate inbound mail to. - contents_file_id: The file containing the PDF contents. If not present, a default check image file will be used. + lockbox_address_id: The identifier of the Lockbox Address to simulate inbound mail to. + + lockbox_recipient_id: The identifier of the Lockbox Recipient to simulate inbound mail to. + extra_headers: Send extra headers extra_query: Add additional query parameters to the request @@ -82,8 +85,9 @@ def create( body=maybe_transform( { "amount": amount, - "lockbox_id": lockbox_id, "contents_file_id": contents_file_id, + "lockbox_address_id": lockbox_address_id, + "lockbox_recipient_id": lockbox_recipient_id, }, inbound_mail_item_create_params.InboundMailItemCreateParams, ), @@ -122,8 +126,9 @@ async def create( self, *, amount: int, - lockbox_id: str, contents_file_id: str | Omit = omit, + lockbox_address_id: str | Omit = omit, + lockbox_recipient_id: 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, @@ -139,11 +144,13 @@ async def create( Args: amount: The amount of the check to be simulated, in cents. - lockbox_id: The identifier of the Lockbox to simulate inbound mail to. - contents_file_id: The file containing the PDF contents. If not present, a default check image file will be used. + lockbox_address_id: The identifier of the Lockbox Address to simulate inbound mail to. + + lockbox_recipient_id: The identifier of the Lockbox Recipient to simulate inbound mail to. + extra_headers: Send extra headers extra_query: Add additional query parameters to the request @@ -159,8 +166,9 @@ async def create( body=await async_maybe_transform( { "amount": amount, - "lockbox_id": lockbox_id, "contents_file_id": contents_file_id, + "lockbox_address_id": lockbox_address_id, + "lockbox_recipient_id": lockbox_recipient_id, }, inbound_mail_item_create_params.InboundMailItemCreateParams, ), diff --git a/src/increase/types/__init__.py b/src/increase/types/__init__.py index d19415dd7..bbe040d12 100644 --- a/src/increase/types/__init__.py +++ b/src/increase/types/__init__.py @@ -9,7 +9,6 @@ from .entity import Entity as Entity from .export import Export as Export from .account import Account as Account -from .lockbox import Lockbox as Lockbox from .program import Program as Program from .file_link import FileLink as FileLink from .card_token import CardToken as CardToken @@ -30,6 +29,7 @@ from .card_validation import CardValidation as CardValidation from .fednow_transfer import FednowTransfer as FednowTransfer from .intrafi_balance import IntrafiBalance as IntrafiBalance +from .lockbox_address import LockboxAddress as LockboxAddress from .account_transfer import AccountTransfer as AccountTransfer from .card_list_params import CardListParams as CardListParams from .external_account import ExternalAccount as ExternalAccount @@ -39,6 +39,7 @@ from .event_list_params import EventListParams as EventListParams from .inbound_mail_item import InboundMailItem as InboundMailItem from .intrafi_exclusion import IntrafiExclusion as IntrafiExclusion +from .lockbox_recipient import LockboxRecipient as LockboxRecipient from .oauth_application import OAuthApplication as OAuthApplication from .card_create_params import CardCreateParams as CardCreateParams from .card_push_transfer import CardPushTransfer as CardPushTransfer @@ -50,7 +51,6 @@ from .real_time_decision import RealTimeDecision as RealTimeDecision from .account_list_params import AccountListParams as AccountListParams from .ach_prenotification import ACHPrenotification as ACHPrenotification -from .lockbox_list_params import LockboxListParams as LockboxListParams from .pending_transaction import PendingTransaction as PendingTransaction from .program_list_params import ProgramListParams as ProgramListParams from .declined_transaction import DeclinedTransaction as DeclinedTransaction @@ -65,8 +65,6 @@ from .account_update_params import AccountUpdateParams as AccountUpdateParams from .inbound_check_deposit import InboundCheckDeposit as InboundCheckDeposit from .inbound_wire_transfer import InboundWireTransfer as InboundWireTransfer -from .lockbox_create_params import LockboxCreateParams as LockboxCreateParams -from .lockbox_update_params import LockboxUpdateParams as LockboxUpdateParams from .physical_card_profile import PhysicalCardProfile as PhysicalCardProfile from .wire_drawdown_request import WireDrawdownRequest as WireDrawdownRequest from .account_balance_params import AccountBalanceParams as AccountBalanceParams @@ -96,6 +94,7 @@ from .card_validation_list_params import CardValidationListParams as CardValidationListParams from .check_deposit_create_params import CheckDepositCreateParams as CheckDepositCreateParams from .fednow_transfer_list_params import FednowTransferListParams as FednowTransferListParams +from .lockbox_address_list_params import LockboxAddressListParams as LockboxAddressListParams from .physical_card_create_params import PhysicalCardCreateParams as PhysicalCardCreateParams from .physical_card_update_params import PhysicalCardUpdateParams as PhysicalCardUpdateParams from .real_time_payments_transfer import RealTimePaymentsTransfer as RealTimePaymentsTransfer @@ -117,6 +116,9 @@ from .inbound_mail_item_list_params import InboundMailItemListParams as InboundMailItemListParams from .inbound_wire_drawdown_request import InboundWireDrawdownRequest as InboundWireDrawdownRequest from .intrafi_exclusion_list_params import IntrafiExclusionListParams as IntrafiExclusionListParams +from .lockbox_address_create_params import LockboxAddressCreateParams as LockboxAddressCreateParams +from .lockbox_address_update_params import LockboxAddressUpdateParams as LockboxAddressUpdateParams +from .lockbox_recipient_list_params import LockboxRecipientListParams as LockboxRecipientListParams from .oauth_application_list_params import OAuthApplicationListParams as OAuthApplicationListParams from .account_transfer_create_params import AccountTransferCreateParams as AccountTransferCreateParams from .beneficial_owner_create_params import BeneficialOwnerCreateParams as BeneficialOwnerCreateParams @@ -128,6 +130,8 @@ from .ach_prenotification_list_params import ACHPrenotificationListParams as ACHPrenotificationListParams from .inbound_mail_item_action_params import InboundMailItemActionParams as InboundMailItemActionParams from .intrafi_exclusion_create_params import IntrafiExclusionCreateParams as IntrafiExclusionCreateParams +from .lockbox_recipient_create_params import LockboxRecipientCreateParams as LockboxRecipientCreateParams +from .lockbox_recipient_update_params import LockboxRecipientUpdateParams as LockboxRecipientUpdateParams from .pending_transaction_list_params import PendingTransactionListParams as PendingTransactionListParams from .card_push_transfer_create_params import CardPushTransferCreateParams as CardPushTransferCreateParams from .declined_transaction_list_params import DeclinedTransactionListParams as DeclinedTransactionListParams diff --git a/src/increase/types/check_deposit.py b/src/increase/types/check_deposit.py index 1eebfc28a..e1f071a5a 100644 --- a/src/increase/types/check_deposit.py +++ b/src/increase/types/check_deposit.py @@ -469,10 +469,11 @@ class CheckDeposit(BaseModel): the identifier of the Inbound Mail Item. """ - lockbox_id: Optional[str] = None + lockbox_recipient_id: Optional[str] = None """ - If the Check Deposit was the result of an Inbound Mail Item, this will contain - the identifier of the Lockbox that received it. + If the Check Deposit was the result of an Inbound Mail Item routed to a Lockbox + Recipient, this will contain the identifier of the Lockbox Recipient that + received it. """ status: Literal["pending", "submitted", "rejected", "returned"] diff --git a/src/increase/types/inbound_mail_item.py b/src/increase/types/inbound_mail_item.py index 3adafc034..86d9ae219 100644 --- a/src/increase/types/inbound_mail_item.py +++ b/src/increase/types/inbound_mail_item.py @@ -36,7 +36,9 @@ class Check(BaseModel): class InboundMailItem(BaseModel): - """Inbound Mail Items represent pieces of physical mail delivered to a Lockbox.""" + """ + Inbound Mail Items represent pieces of physical mail delivered to a Lockbox Address. + """ id: str """The Inbound Mail Item identifier.""" @@ -53,22 +55,36 @@ class InboundMailItem(BaseModel): file_id: str """The identifier for the File containing the scanned contents of the mail item.""" - lockbox_id: Optional[str] = None - """The identifier for the Lockbox that received this mail item. + lockbox_address_id: Optional[str] = None + """The identifier for the Lockbox Address that received this mail item.""" + + lockbox_recipient_id: Optional[str] = None + """The identifier for the Lockbox Recipient that received this mail item. - For mail items that could not be processed due to an invalid address, this will - be null. + For mail items that could not be routed to a Lockbox Recipient, this will be + null. """ recipient_name: Optional[str] = None """The recipient name as written on the mail item.""" - rejection_reason: Optional[Literal["no_matching_lockbox", "no_check", "lockbox_not_active"]] = None + rejection_reason: Optional[ + Literal[ + "no_matching_lockbox", + "no_check", + "lockbox_not_active", + "lockbox_address_not_active", + "lockbox_recipient_not_active", + ] + ] = None """If the mail item has been rejected, why it was rejected. - `no_matching_lockbox` - The mail item does not match any lockbox. - `no_check` - The mail item does not contain a check. - `lockbox_not_active` - The Lockbox or its associated Account is not active. + - `lockbox_address_not_active` - The Lockbox Address is not active. + - `lockbox_recipient_not_active` - The Lockbox Recipient or its associated + Account is not active. """ status: Literal["pending", "processed", "rejected"] diff --git a/src/increase/types/inbound_mail_item_list_params.py b/src/increase/types/inbound_mail_item_list_params.py index 403b80cec..e19e8d840 100644 --- a/src/increase/types/inbound_mail_item_list_params.py +++ b/src/increase/types/inbound_mail_item_list_params.py @@ -23,8 +23,11 @@ class InboundMailItemListParams(TypedDict, total=False): The default (and maximum) is 100 objects. """ - lockbox_id: str - """Filter Inbound Mail Items to ones sent to the provided Lockbox.""" + lockbox_address_id: str + """Filter Inbound Mail Items to ones sent to the provided Lockbox Address.""" + + lockbox_recipient_id: str + """Filter Inbound Mail Items to ones sent to the provided Lockbox Recipient.""" class CreatedAt(TypedDict, total=False): diff --git a/src/increase/types/lockbox.py b/src/increase/types/lockbox.py deleted file mode 100644 index 76a76c374..000000000 --- a/src/increase/types/lockbox.py +++ /dev/null @@ -1,107 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from typing import TYPE_CHECKING, Dict, Optional -from datetime import datetime -from typing_extensions import Literal - -from pydantic import Field as FieldInfo - -from .._models import BaseModel - -__all__ = ["Lockbox", "Address"] - - -class Address(BaseModel): - """The mailing address for the Lockbox.""" - - city: str - """The city of the address.""" - - line1: str - """The first line of the address.""" - - line2: str - """The second line of the address.""" - - postal_code: str - """The postal code of the address.""" - - recipient: Optional[str] = None - """The recipient line of the address. - - This will include the recipient name you provide when creating the address, as - well as an ATTN suffix to help route the mail to your lockbox. Mail senders must - include this ATTN line to receive mail at this Lockbox. - """ - - state: str - """ - The two-letter United States Postal Service (USPS) abbreviation for the state of - the address. - """ - - -class Lockbox(BaseModel): - """Lockboxes are physical locations that can receive mail containing paper checks. - - Increase will automatically create a Check Deposit for checks received this way. - """ - - id: str - """The Lockbox identifier.""" - - account_id: str - """ - The identifier for the Account checks sent to this lockbox will be deposited - into. - """ - - address: Address - """The mailing address for the Lockbox.""" - - check_deposit_behavior: Literal["enabled", "disabled", "pend_for_processing"] - """Indicates if checks mailed to this lockbox will be deposited. - - - `enabled` - Checks mailed to this Lockbox will be deposited. - - `disabled` - Checks mailed to this Lockbox will not be deposited. - - `pend_for_processing` - Checks mailed to this Lockbox will be pending until - actioned. - """ - - created_at: datetime - """ - The [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) time at which the Lockbox - was created. - """ - - description: Optional[str] = None - """The description you choose for the Lockbox.""" - - idempotency_key: Optional[str] = None - """The idempotency key you chose for this object. - - This value is unique across Increase and is used to ensure that a request is - only processed once. Learn more about - [idempotency](https://increase.com/documentation/idempotency-keys). - """ - - recipient_name: Optional[str] = None - """The recipient name you choose for the Lockbox.""" - - type: Literal["lockbox"] - """A constant representing the object's type. - - For this resource it will always be `lockbox`. - """ - - if TYPE_CHECKING: - # Some versions of Pydantic <2.8.0 have a bug and don’t allow assigning a - # value to this field, so for compatibility we avoid doing it at runtime. - __pydantic_extra__: Dict[str, object] = FieldInfo(init=False) # pyright: ignore[reportIncompatibleVariableOverride] - - # Stub to indicate that arbitrary properties are accepted. - # To access properties that are not valid identifiers you can use `getattr`, e.g. - # `getattr(obj, '$type')` - def __getattr__(self, attr: str) -> object: ... - else: - __pydantic_extra__: Dict[str, object] diff --git a/src/increase/types/lockbox_address.py b/src/increase/types/lockbox_address.py new file mode 100644 index 000000000..20bbd4210 --- /dev/null +++ b/src/increase/types/lockbox_address.py @@ -0,0 +1,81 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import Optional +from datetime import datetime +from typing_extensions import Literal + +from .._models import BaseModel + +__all__ = ["LockboxAddress", "Address"] + + +class Address(BaseModel): + """The mailing address for the Lockbox Address. + + It will be present after Increase generates it. + """ + + city: str + """The city of the address.""" + + line1: str + """The first line of the address.""" + + line2: str + """The second line of the address.""" + + postal_code: str + """The postal code of the address.""" + + state: str + """ + The two-letter United States Postal Service (USPS) abbreviation for the state of + the address. + """ + + +class LockboxAddress(BaseModel): + """ + Lockbox Addresses are physical locations that can receive mail containing paper checks. + """ + + id: str + """The Lockbox Address identifier.""" + + address: Optional[Address] = None + """The mailing address for the Lockbox Address. + + It will be present after Increase generates it. + """ + + created_at: datetime + """ + The [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) time at which the Lockbox + Address was created. + """ + + description: Optional[str] = None + """The description you choose for the Lockbox Address.""" + + idempotency_key: Optional[str] = None + """The idempotency key you chose for this object. + + This value is unique across Increase and is used to ensure that a request is + only processed once. Learn more about + [idempotency](https://increase.com/documentation/idempotency-keys). + """ + + status: Literal["pending", "active", "disabled", "canceled"] + """The status of the Lockbox Address. + + - `pending` - Increase is generating this Lockbox Address. + - `active` - This Lockbox Address is active. + - `disabled` - This Lockbox Address is disabled. + - `canceled` - This Lockbox Address is permanently disabled. + """ + + type: Literal["lockbox_address"] + """A constant representing the object's type. + + For this resource it will always be `lockbox_address`. + """ diff --git a/src/increase/types/lockbox_address_create_params.py b/src/increase/types/lockbox_address_create_params.py new file mode 100644 index 000000000..a05808299 --- /dev/null +++ b/src/increase/types/lockbox_address_create_params.py @@ -0,0 +1,12 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing_extensions import TypedDict + +__all__ = ["LockboxAddressCreateParams"] + + +class LockboxAddressCreateParams(TypedDict, total=False): + description: str + """The description you choose for the Lockbox Address.""" diff --git a/src/increase/types/lockbox_list_params.py b/src/increase/types/lockbox_address_list_params.py similarity index 89% rename from src/increase/types/lockbox_list_params.py rename to src/increase/types/lockbox_address_list_params.py index 4cf817765..8784d897d 100644 --- a/src/increase/types/lockbox_list_params.py +++ b/src/increase/types/lockbox_address_list_params.py @@ -8,13 +8,10 @@ from .._utils import PropertyInfo -__all__ = ["LockboxListParams", "CreatedAt"] +__all__ = ["LockboxAddressListParams", "CreatedAt"] -class LockboxListParams(TypedDict, total=False): - account_id: str - """Filter Lockboxes to those associated with the provided Account.""" - +class LockboxAddressListParams(TypedDict, total=False): created_at: CreatedAt cursor: str diff --git a/src/increase/types/lockbox_address_update_params.py b/src/increase/types/lockbox_address_update_params.py new file mode 100644 index 000000000..5238f0b5a --- /dev/null +++ b/src/increase/types/lockbox_address_update_params.py @@ -0,0 +1,20 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing_extensions import Literal, TypedDict + +__all__ = ["LockboxAddressUpdateParams"] + + +class LockboxAddressUpdateParams(TypedDict, total=False): + description: str + """The description you choose for the Lockbox Address.""" + + status: Literal["active", "disabled", "canceled"] + """The status of the Lockbox Address. + + - `active` - This Lockbox Address is active. + - `disabled` - This Lockbox Address is disabled. + - `canceled` - This Lockbox Address is permanently disabled. + """ diff --git a/src/increase/types/lockbox_create_params.py b/src/increase/types/lockbox_create_params.py deleted file mode 100644 index bea106ab9..000000000 --- a/src/increase/types/lockbox_create_params.py +++ /dev/null @@ -1,18 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from __future__ import annotations - -from typing_extensions import Required, TypedDict - -__all__ = ["LockboxCreateParams"] - - -class LockboxCreateParams(TypedDict, total=False): - account_id: Required[str] - """The Account checks sent to this Lockbox should be deposited into.""" - - description: str - """The description you choose for the Lockbox, for display purposes.""" - - recipient_name: str - """The name of the recipient that will receive mail at this location.""" diff --git a/src/increase/types/lockbox_recipient.py b/src/increase/types/lockbox_recipient.py new file mode 100644 index 000000000..17c4640fe --- /dev/null +++ b/src/increase/types/lockbox_recipient.py @@ -0,0 +1,74 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import Optional +from datetime import datetime +from typing_extensions import Literal + +from .._models import BaseModel + +__all__ = ["LockboxRecipient"] + + +class LockboxRecipient(BaseModel): + """Lockbox Recipients represent an inbox at a Lockbox Address. + + Checks received for a Lockbox Recipient are deposited into its associated Account. + """ + + id: str + """The Lockbox Recipient identifier.""" + + account_id: str + """ + The identifier for the Account that checks sent to this Lockbox Recipient will + be deposited into. + """ + + created_at: datetime + """ + The [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) time at which the Lockbox + Recipient was created. + """ + + description: Optional[str] = None + """The description of the Lockbox Recipient.""" + + idempotency_key: Optional[str] = None + """The idempotency key you chose for this object. + + This value is unique across Increase and is used to ensure that a request is + only processed once. Learn more about + [idempotency](https://increase.com/documentation/idempotency-keys). + """ + + lockbox_address_id: str + """ + The identifier for the Lockbox Address where this Lockbox Recipient may receive + physical mail. + """ + + mail_stop_code: str + """ + The mail stop code uniquely identifying this Lockbox Recipient at its Lockbox + Address. It should be included in the mailing address intended for this Lockbox + Recipient. + """ + + recipient_name: Optional[str] = None + """The name of the Lockbox Recipient.""" + + status: Optional[Literal["active", "disabled", "canceled"]] = None + """The status of the Lockbox Recipient. + + - `active` - This Lockbox Recipient is active. + - `disabled` - This Lockbox Recipient is disabled. Checks mailed to this Lockbox + Recipient will be rejected. + - `canceled` - This Lockbox Recipient is canceled and cannot be modified. Checks + mailed to this Lockbox Recipient will be rejected. + """ + + type: Literal["lockbox_recipient"] + """A constant representing the object's type. + + For this resource it will always be `lockbox_recipient`. + """ diff --git a/src/increase/types/lockbox_recipient_create_params.py b/src/increase/types/lockbox_recipient_create_params.py new file mode 100644 index 000000000..2acb4c8ed --- /dev/null +++ b/src/increase/types/lockbox_recipient_create_params.py @@ -0,0 +1,23 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing_extensions import Required, TypedDict + +__all__ = ["LockboxRecipientCreateParams"] + + +class LockboxRecipientCreateParams(TypedDict, total=False): + account_id: Required[str] + """ + The Account that checks sent to this Lockbox Recipient should be deposited into. + """ + + lockbox_address_id: Required[str] + """The Lockbox Address where this Lockbox Recipient may receive mail.""" + + description: str + """The description you choose for the Lockbox Recipient.""" + + recipient_name: str + """The name of the Lockbox Recipient""" diff --git a/src/increase/types/lockbox_recipient_list_params.py b/src/increase/types/lockbox_recipient_list_params.py new file mode 100644 index 000000000..ed798394a --- /dev/null +++ b/src/increase/types/lockbox_recipient_list_params.py @@ -0,0 +1,66 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Union +from datetime import datetime +from typing_extensions import Annotated, TypedDict + +from .._utils import PropertyInfo + +__all__ = ["LockboxRecipientListParams", "CreatedAt"] + + +class LockboxRecipientListParams(TypedDict, total=False): + account_id: str + """Filter Lockbox Recipients to those associated with the provided Account.""" + + created_at: CreatedAt + + cursor: str + """Return the page of entries after this one.""" + + idempotency_key: str + """ + Filter records to the one with the specified `idempotency_key` you chose for + that object. This value is unique across Increase and is used to ensure that a + request is only processed once. Learn more about + [idempotency](https://increase.com/documentation/idempotency-keys). + """ + + limit: int + """Limit the size of the list that is returned. + + The default (and maximum) is 100 objects. + """ + + lockbox_address_id: str + """ + Filter Lockbox Recipients to those associated with the provided Lockbox Address. + """ + + +class CreatedAt(TypedDict, total=False): + after: Annotated[Union[str, datetime], PropertyInfo(format="iso8601")] + """ + Return results after this [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) + timestamp. + """ + + before: Annotated[Union[str, datetime], PropertyInfo(format="iso8601")] + """ + Return results before this [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) + timestamp. + """ + + on_or_after: Annotated[Union[str, datetime], PropertyInfo(format="iso8601")] + """ + Return results on or after this + [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) timestamp. + """ + + on_or_before: Annotated[Union[str, datetime], PropertyInfo(format="iso8601")] + """ + Return results on or before this + [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) timestamp. + """ diff --git a/src/increase/types/lockbox_recipient_update_params.py b/src/increase/types/lockbox_recipient_update_params.py new file mode 100644 index 000000000..f3548ae5c --- /dev/null +++ b/src/increase/types/lockbox_recipient_update_params.py @@ -0,0 +1,25 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing_extensions import Literal, TypedDict + +__all__ = ["LockboxRecipientUpdateParams"] + + +class LockboxRecipientUpdateParams(TypedDict, total=False): + description: str + """The description you choose for the Lockbox Recipient.""" + + recipient_name: str + """The name of the Lockbox Recipient.""" + + status: Literal["active", "disabled", "canceled"] + """The status of the Lockbox Recipient. + + - `active` - This Lockbox Recipient is active. + - `disabled` - This Lockbox Recipient is disabled. Checks mailed to this Lockbox + Recipient will be rejected. + - `canceled` - This Lockbox Recipient is canceled and cannot be modified. Checks + mailed to this Lockbox Recipient will be rejected. + """ diff --git a/src/increase/types/lockbox_update_params.py b/src/increase/types/lockbox_update_params.py deleted file mode 100644 index ce7a4e72e..000000000 --- a/src/increase/types/lockbox_update_params.py +++ /dev/null @@ -1,24 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from __future__ import annotations - -from typing_extensions import Literal, TypedDict - -__all__ = ["LockboxUpdateParams"] - - -class LockboxUpdateParams(TypedDict, total=False): - check_deposit_behavior: Literal["enabled", "disabled", "pend_for_processing"] - """This indicates if checks mailed to this lockbox will be deposited. - - - `enabled` - Checks mailed to this Lockbox will be deposited. - - `disabled` - Checks mailed to this Lockbox will not be deposited. - - `pend_for_processing` - Checks mailed to this Lockbox will be pending until - actioned. - """ - - description: str - """The description you choose for the Lockbox.""" - - recipient_name: str - """The recipient name you choose for the Lockbox.""" diff --git a/src/increase/types/simulations/inbound_mail_item_create_params.py b/src/increase/types/simulations/inbound_mail_item_create_params.py index bbbc2ef15..1643cc029 100755 --- a/src/increase/types/simulations/inbound_mail_item_create_params.py +++ b/src/increase/types/simulations/inbound_mail_item_create_params.py @@ -11,11 +11,14 @@ class InboundMailItemCreateParams(TypedDict, total=False): amount: Required[int] """The amount of the check to be simulated, in cents.""" - lockbox_id: Required[str] - """The identifier of the Lockbox to simulate inbound mail to.""" - contents_file_id: str """The file containing the PDF contents. If not present, a default check image file will be used. """ + + lockbox_address_id: str + """The identifier of the Lockbox Address to simulate inbound mail to.""" + + lockbox_recipient_id: str + """The identifier of the Lockbox Recipient to simulate inbound mail to.""" diff --git a/tests/api_resources/simulations/test_inbound_mail_items.py b/tests/api_resources/simulations/test_inbound_mail_items.py index cb86a0502..c3ed6d572 100755 --- a/tests/api_resources/simulations/test_inbound_mail_items.py +++ b/tests/api_resources/simulations/test_inbound_mail_items.py @@ -21,7 +21,6 @@ class TestInboundMailItems: def test_method_create(self, client: Increase) -> None: inbound_mail_item = client.simulations.inbound_mail_items.create( amount=1000, - lockbox_id="lockbox_3xt21ok13q19advds4t5", ) assert_matches_type(InboundMailItem, inbound_mail_item, path=["response"]) @@ -29,8 +28,9 @@ def test_method_create(self, client: Increase) -> None: def test_method_create_with_all_params(self, client: Increase) -> None: inbound_mail_item = client.simulations.inbound_mail_items.create( amount=1000, - lockbox_id="lockbox_3xt21ok13q19advds4t5", contents_file_id="contents_file_id", + lockbox_address_id="lockbox_address_id", + lockbox_recipient_id="lockbox_3xt21ok13q19advds4t5", ) assert_matches_type(InboundMailItem, inbound_mail_item, path=["response"]) @@ -38,7 +38,6 @@ def test_method_create_with_all_params(self, client: Increase) -> None: def test_raw_response_create(self, client: Increase) -> None: response = client.simulations.inbound_mail_items.with_raw_response.create( amount=1000, - lockbox_id="lockbox_3xt21ok13q19advds4t5", ) assert response.is_closed is True @@ -50,7 +49,6 @@ def test_raw_response_create(self, client: Increase) -> None: def test_streaming_response_create(self, client: Increase) -> None: with client.simulations.inbound_mail_items.with_streaming_response.create( amount=1000, - lockbox_id="lockbox_3xt21ok13q19advds4t5", ) as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" @@ -70,7 +68,6 @@ class TestAsyncInboundMailItems: async def test_method_create(self, async_client: AsyncIncrease) -> None: inbound_mail_item = await async_client.simulations.inbound_mail_items.create( amount=1000, - lockbox_id="lockbox_3xt21ok13q19advds4t5", ) assert_matches_type(InboundMailItem, inbound_mail_item, path=["response"]) @@ -78,8 +75,9 @@ async def test_method_create(self, async_client: AsyncIncrease) -> None: async def test_method_create_with_all_params(self, async_client: AsyncIncrease) -> None: inbound_mail_item = await async_client.simulations.inbound_mail_items.create( amount=1000, - lockbox_id="lockbox_3xt21ok13q19advds4t5", contents_file_id="contents_file_id", + lockbox_address_id="lockbox_address_id", + lockbox_recipient_id="lockbox_3xt21ok13q19advds4t5", ) assert_matches_type(InboundMailItem, inbound_mail_item, path=["response"]) @@ -87,7 +85,6 @@ async def test_method_create_with_all_params(self, async_client: AsyncIncrease) async def test_raw_response_create(self, async_client: AsyncIncrease) -> None: response = await async_client.simulations.inbound_mail_items.with_raw_response.create( amount=1000, - lockbox_id="lockbox_3xt21ok13q19advds4t5", ) assert response.is_closed is True @@ -99,7 +96,6 @@ async def test_raw_response_create(self, async_client: AsyncIncrease) -> None: async def test_streaming_response_create(self, async_client: AsyncIncrease) -> None: async with async_client.simulations.inbound_mail_items.with_streaming_response.create( amount=1000, - lockbox_id="lockbox_3xt21ok13q19advds4t5", ) as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" diff --git a/tests/api_resources/test_inbound_mail_items.py b/tests/api_resources/test_inbound_mail_items.py index 8f4229b5e..4bf6005f1 100644 --- a/tests/api_resources/test_inbound_mail_items.py +++ b/tests/api_resources/test_inbound_mail_items.py @@ -73,7 +73,8 @@ def test_method_list_with_all_params(self, client: Increase) -> None: }, cursor="cursor", limit=1, - lockbox_id="lockbox_id", + lockbox_address_id="lockbox_address_id", + lockbox_recipient_id="lockbox_recipient_id", ) assert_matches_type(SyncPage[InboundMailItem], inbound_mail_item, path=["response"]) @@ -199,7 +200,8 @@ async def test_method_list_with_all_params(self, async_client: AsyncIncrease) -> }, cursor="cursor", limit=1, - lockbox_id="lockbox_id", + lockbox_address_id="lockbox_address_id", + lockbox_recipient_id="lockbox_recipient_id", ) assert_matches_type(AsyncPage[InboundMailItem], inbound_mail_item, path=["response"]) diff --git a/tests/api_resources/test_lockbox_addresses.py b/tests/api_resources/test_lockbox_addresses.py new file mode 100644 index 000000000..3549feb4b --- /dev/null +++ b/tests/api_resources/test_lockbox_addresses.py @@ -0,0 +1,342 @@ +# 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 increase import Increase, AsyncIncrease +from tests.utils import assert_matches_type +from increase.types import ( + LockboxAddress, +) +from increase._utils import parse_datetime +from increase.pagination import SyncPage, AsyncPage + +base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") + + +class TestLockboxAddresses: + parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) + + @parametrize + def test_method_create(self, client: Increase) -> None: + lockbox_address = client.lockbox_addresses.create() + assert_matches_type(LockboxAddress, lockbox_address, path=["response"]) + + @parametrize + def test_method_create_with_all_params(self, client: Increase) -> None: + lockbox_address = client.lockbox_addresses.create( + description="Lockbox Address 1", + ) + assert_matches_type(LockboxAddress, lockbox_address, path=["response"]) + + @parametrize + def test_raw_response_create(self, client: Increase) -> None: + response = client.lockbox_addresses.with_raw_response.create() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + lockbox_address = response.parse() + assert_matches_type(LockboxAddress, lockbox_address, path=["response"]) + + @parametrize + def test_streaming_response_create(self, client: Increase) -> None: + with client.lockbox_addresses.with_streaming_response.create() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + lockbox_address = response.parse() + assert_matches_type(LockboxAddress, lockbox_address, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_method_retrieve(self, client: Increase) -> None: + lockbox_address = client.lockbox_addresses.retrieve( + "lockbox_address_lw6sbzl9ol5dfd8hdml6", + ) + assert_matches_type(LockboxAddress, lockbox_address, path=["response"]) + + @parametrize + def test_raw_response_retrieve(self, client: Increase) -> None: + response = client.lockbox_addresses.with_raw_response.retrieve( + "lockbox_address_lw6sbzl9ol5dfd8hdml6", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + lockbox_address = response.parse() + assert_matches_type(LockboxAddress, lockbox_address, path=["response"]) + + @parametrize + def test_streaming_response_retrieve(self, client: Increase) -> None: + with client.lockbox_addresses.with_streaming_response.retrieve( + "lockbox_address_lw6sbzl9ol5dfd8hdml6", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + lockbox_address = response.parse() + assert_matches_type(LockboxAddress, lockbox_address, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_path_params_retrieve(self, client: Increase) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `lockbox_address_id` but received ''"): + client.lockbox_addresses.with_raw_response.retrieve( + "", + ) + + @parametrize + def test_method_update(self, client: Increase) -> None: + lockbox_address = client.lockbox_addresses.update( + lockbox_address_id="lockbox_address_lw6sbzl9ol5dfd8hdml6", + ) + assert_matches_type(LockboxAddress, lockbox_address, path=["response"]) + + @parametrize + def test_method_update_with_all_params(self, client: Increase) -> None: + lockbox_address = client.lockbox_addresses.update( + lockbox_address_id="lockbox_address_lw6sbzl9ol5dfd8hdml6", + description="x", + status="disabled", + ) + assert_matches_type(LockboxAddress, lockbox_address, path=["response"]) + + @parametrize + def test_raw_response_update(self, client: Increase) -> None: + response = client.lockbox_addresses.with_raw_response.update( + lockbox_address_id="lockbox_address_lw6sbzl9ol5dfd8hdml6", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + lockbox_address = response.parse() + assert_matches_type(LockboxAddress, lockbox_address, path=["response"]) + + @parametrize + def test_streaming_response_update(self, client: Increase) -> None: + with client.lockbox_addresses.with_streaming_response.update( + lockbox_address_id="lockbox_address_lw6sbzl9ol5dfd8hdml6", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + lockbox_address = response.parse() + assert_matches_type(LockboxAddress, lockbox_address, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_path_params_update(self, client: Increase) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `lockbox_address_id` but received ''"): + client.lockbox_addresses.with_raw_response.update( + lockbox_address_id="", + ) + + @parametrize + def test_method_list(self, client: Increase) -> None: + lockbox_address = client.lockbox_addresses.list() + assert_matches_type(SyncPage[LockboxAddress], lockbox_address, path=["response"]) + + @parametrize + def test_method_list_with_all_params(self, client: Increase) -> None: + lockbox_address = client.lockbox_addresses.list( + created_at={ + "after": parse_datetime("2019-12-27T18:11:19.117Z"), + "before": parse_datetime("2019-12-27T18:11:19.117Z"), + "on_or_after": parse_datetime("2019-12-27T18:11:19.117Z"), + "on_or_before": parse_datetime("2019-12-27T18:11:19.117Z"), + }, + cursor="cursor", + idempotency_key="x", + limit=1, + ) + assert_matches_type(SyncPage[LockboxAddress], lockbox_address, path=["response"]) + + @parametrize + def test_raw_response_list(self, client: Increase) -> None: + response = client.lockbox_addresses.with_raw_response.list() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + lockbox_address = response.parse() + assert_matches_type(SyncPage[LockboxAddress], lockbox_address, path=["response"]) + + @parametrize + def test_streaming_response_list(self, client: Increase) -> None: + with client.lockbox_addresses.with_streaming_response.list() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + lockbox_address = response.parse() + assert_matches_type(SyncPage[LockboxAddress], lockbox_address, path=["response"]) + + assert cast(Any, response.is_closed) is True + + +class TestAsyncLockboxAddresses: + parametrize = pytest.mark.parametrize( + "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] + ) + + @parametrize + async def test_method_create(self, async_client: AsyncIncrease) -> None: + lockbox_address = await async_client.lockbox_addresses.create() + assert_matches_type(LockboxAddress, lockbox_address, path=["response"]) + + @parametrize + async def test_method_create_with_all_params(self, async_client: AsyncIncrease) -> None: + lockbox_address = await async_client.lockbox_addresses.create( + description="Lockbox Address 1", + ) + assert_matches_type(LockboxAddress, lockbox_address, path=["response"]) + + @parametrize + async def test_raw_response_create(self, async_client: AsyncIncrease) -> None: + response = await async_client.lockbox_addresses.with_raw_response.create() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + lockbox_address = await response.parse() + assert_matches_type(LockboxAddress, lockbox_address, path=["response"]) + + @parametrize + async def test_streaming_response_create(self, async_client: AsyncIncrease) -> None: + async with async_client.lockbox_addresses.with_streaming_response.create() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + lockbox_address = await response.parse() + assert_matches_type(LockboxAddress, lockbox_address, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_method_retrieve(self, async_client: AsyncIncrease) -> None: + lockbox_address = await async_client.lockbox_addresses.retrieve( + "lockbox_address_lw6sbzl9ol5dfd8hdml6", + ) + assert_matches_type(LockboxAddress, lockbox_address, path=["response"]) + + @parametrize + async def test_raw_response_retrieve(self, async_client: AsyncIncrease) -> None: + response = await async_client.lockbox_addresses.with_raw_response.retrieve( + "lockbox_address_lw6sbzl9ol5dfd8hdml6", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + lockbox_address = await response.parse() + assert_matches_type(LockboxAddress, lockbox_address, path=["response"]) + + @parametrize + async def test_streaming_response_retrieve(self, async_client: AsyncIncrease) -> None: + async with async_client.lockbox_addresses.with_streaming_response.retrieve( + "lockbox_address_lw6sbzl9ol5dfd8hdml6", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + lockbox_address = await response.parse() + assert_matches_type(LockboxAddress, lockbox_address, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_path_params_retrieve(self, async_client: AsyncIncrease) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `lockbox_address_id` but received ''"): + await async_client.lockbox_addresses.with_raw_response.retrieve( + "", + ) + + @parametrize + async def test_method_update(self, async_client: AsyncIncrease) -> None: + lockbox_address = await async_client.lockbox_addresses.update( + lockbox_address_id="lockbox_address_lw6sbzl9ol5dfd8hdml6", + ) + assert_matches_type(LockboxAddress, lockbox_address, path=["response"]) + + @parametrize + async def test_method_update_with_all_params(self, async_client: AsyncIncrease) -> None: + lockbox_address = await async_client.lockbox_addresses.update( + lockbox_address_id="lockbox_address_lw6sbzl9ol5dfd8hdml6", + description="x", + status="disabled", + ) + assert_matches_type(LockboxAddress, lockbox_address, path=["response"]) + + @parametrize + async def test_raw_response_update(self, async_client: AsyncIncrease) -> None: + response = await async_client.lockbox_addresses.with_raw_response.update( + lockbox_address_id="lockbox_address_lw6sbzl9ol5dfd8hdml6", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + lockbox_address = await response.parse() + assert_matches_type(LockboxAddress, lockbox_address, path=["response"]) + + @parametrize + async def test_streaming_response_update(self, async_client: AsyncIncrease) -> None: + async with async_client.lockbox_addresses.with_streaming_response.update( + lockbox_address_id="lockbox_address_lw6sbzl9ol5dfd8hdml6", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + lockbox_address = await response.parse() + assert_matches_type(LockboxAddress, lockbox_address, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_path_params_update(self, async_client: AsyncIncrease) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `lockbox_address_id` but received ''"): + await async_client.lockbox_addresses.with_raw_response.update( + lockbox_address_id="", + ) + + @parametrize + async def test_method_list(self, async_client: AsyncIncrease) -> None: + lockbox_address = await async_client.lockbox_addresses.list() + assert_matches_type(AsyncPage[LockboxAddress], lockbox_address, path=["response"]) + + @parametrize + async def test_method_list_with_all_params(self, async_client: AsyncIncrease) -> None: + lockbox_address = await async_client.lockbox_addresses.list( + created_at={ + "after": parse_datetime("2019-12-27T18:11:19.117Z"), + "before": parse_datetime("2019-12-27T18:11:19.117Z"), + "on_or_after": parse_datetime("2019-12-27T18:11:19.117Z"), + "on_or_before": parse_datetime("2019-12-27T18:11:19.117Z"), + }, + cursor="cursor", + idempotency_key="x", + limit=1, + ) + assert_matches_type(AsyncPage[LockboxAddress], lockbox_address, path=["response"]) + + @parametrize + async def test_raw_response_list(self, async_client: AsyncIncrease) -> None: + response = await async_client.lockbox_addresses.with_raw_response.list() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + lockbox_address = await response.parse() + assert_matches_type(AsyncPage[LockboxAddress], lockbox_address, path=["response"]) + + @parametrize + async def test_streaming_response_list(self, async_client: AsyncIncrease) -> None: + async with async_client.lockbox_addresses.with_streaming_response.list() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + lockbox_address = await response.parse() + assert_matches_type(AsyncPage[LockboxAddress], lockbox_address, path=["response"]) + + assert cast(Any, response.is_closed) is True diff --git a/tests/api_resources/test_lockboxes.py b/tests/api_resources/test_lockbox_recipients.py similarity index 53% rename from tests/api_resources/test_lockboxes.py rename to tests/api_resources/test_lockbox_recipients.py index b8e2b12b9..273792d8e 100644 --- a/tests/api_resources/test_lockboxes.py +++ b/tests/api_resources/test_lockbox_recipients.py @@ -9,150 +9,156 @@ from increase import Increase, AsyncIncrease from tests.utils import assert_matches_type -from increase.types import Lockbox +from increase.types import ( + LockboxRecipient, +) from increase._utils import parse_datetime from increase.pagination import SyncPage, AsyncPage base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") -class TestLockboxes: +class TestLockboxRecipients: parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) @parametrize def test_method_create(self, client: Increase) -> None: - lockbox = client.lockboxes.create( + lockbox_recipient = client.lockbox_recipients.create( account_id="account_in71c4amph0vgo2qllky", + lockbox_address_id="lockbox_address_lw6sbzl9ol5dfd8hdml6", ) - assert_matches_type(Lockbox, lockbox, path=["response"]) + assert_matches_type(LockboxRecipient, lockbox_recipient, path=["response"]) @parametrize def test_method_create_with_all_params(self, client: Increase) -> None: - lockbox = client.lockboxes.create( + lockbox_recipient = client.lockbox_recipients.create( account_id="account_in71c4amph0vgo2qllky", - description="Rent payments", - recipient_name="x", + lockbox_address_id="lockbox_address_lw6sbzl9ol5dfd8hdml6", + description="x", + recipient_name="Ian Crease", ) - assert_matches_type(Lockbox, lockbox, path=["response"]) + assert_matches_type(LockboxRecipient, lockbox_recipient, path=["response"]) @parametrize def test_raw_response_create(self, client: Increase) -> None: - response = client.lockboxes.with_raw_response.create( + response = client.lockbox_recipients.with_raw_response.create( account_id="account_in71c4amph0vgo2qllky", + lockbox_address_id="lockbox_address_lw6sbzl9ol5dfd8hdml6", ) assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" - lockbox = response.parse() - assert_matches_type(Lockbox, lockbox, path=["response"]) + lockbox_recipient = response.parse() + assert_matches_type(LockboxRecipient, lockbox_recipient, path=["response"]) @parametrize def test_streaming_response_create(self, client: Increase) -> None: - with client.lockboxes.with_streaming_response.create( + with client.lockbox_recipients.with_streaming_response.create( account_id="account_in71c4amph0vgo2qllky", + lockbox_address_id="lockbox_address_lw6sbzl9ol5dfd8hdml6", ) as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" - lockbox = response.parse() - assert_matches_type(Lockbox, lockbox, path=["response"]) + lockbox_recipient = response.parse() + assert_matches_type(LockboxRecipient, lockbox_recipient, path=["response"]) assert cast(Any, response.is_closed) is True @parametrize def test_method_retrieve(self, client: Increase) -> None: - lockbox = client.lockboxes.retrieve( + lockbox_recipient = client.lockbox_recipients.retrieve( "lockbox_3xt21ok13q19advds4t5", ) - assert_matches_type(Lockbox, lockbox, path=["response"]) + assert_matches_type(LockboxRecipient, lockbox_recipient, path=["response"]) @parametrize def test_raw_response_retrieve(self, client: Increase) -> None: - response = client.lockboxes.with_raw_response.retrieve( + response = client.lockbox_recipients.with_raw_response.retrieve( "lockbox_3xt21ok13q19advds4t5", ) assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" - lockbox = response.parse() - assert_matches_type(Lockbox, lockbox, path=["response"]) + lockbox_recipient = response.parse() + assert_matches_type(LockboxRecipient, lockbox_recipient, path=["response"]) @parametrize def test_streaming_response_retrieve(self, client: Increase) -> None: - with client.lockboxes.with_streaming_response.retrieve( + with client.lockbox_recipients.with_streaming_response.retrieve( "lockbox_3xt21ok13q19advds4t5", ) as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" - lockbox = response.parse() - assert_matches_type(Lockbox, lockbox, path=["response"]) + lockbox_recipient = response.parse() + assert_matches_type(LockboxRecipient, lockbox_recipient, path=["response"]) assert cast(Any, response.is_closed) is True @parametrize def test_path_params_retrieve(self, client: Increase) -> None: - with pytest.raises(ValueError, match=r"Expected a non-empty value for `lockbox_id` but received ''"): - client.lockboxes.with_raw_response.retrieve( + with pytest.raises(ValueError, match=r"Expected a non-empty value for `lockbox_recipient_id` but received ''"): + client.lockbox_recipients.with_raw_response.retrieve( "", ) @parametrize def test_method_update(self, client: Increase) -> None: - lockbox = client.lockboxes.update( - lockbox_id="lockbox_3xt21ok13q19advds4t5", + lockbox_recipient = client.lockbox_recipients.update( + lockbox_recipient_id="lockbox_3xt21ok13q19advds4t5", ) - assert_matches_type(Lockbox, lockbox, path=["response"]) + assert_matches_type(LockboxRecipient, lockbox_recipient, path=["response"]) @parametrize def test_method_update_with_all_params(self, client: Increase) -> None: - lockbox = client.lockboxes.update( - lockbox_id="lockbox_3xt21ok13q19advds4t5", - check_deposit_behavior="disabled", + lockbox_recipient = client.lockbox_recipients.update( + lockbox_recipient_id="lockbox_3xt21ok13q19advds4t5", description="x", recipient_name="x", + status="active", ) - assert_matches_type(Lockbox, lockbox, path=["response"]) + assert_matches_type(LockboxRecipient, lockbox_recipient, path=["response"]) @parametrize def test_raw_response_update(self, client: Increase) -> None: - response = client.lockboxes.with_raw_response.update( - lockbox_id="lockbox_3xt21ok13q19advds4t5", + response = client.lockbox_recipients.with_raw_response.update( + lockbox_recipient_id="lockbox_3xt21ok13q19advds4t5", ) assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" - lockbox = response.parse() - assert_matches_type(Lockbox, lockbox, path=["response"]) + lockbox_recipient = response.parse() + assert_matches_type(LockboxRecipient, lockbox_recipient, path=["response"]) @parametrize def test_streaming_response_update(self, client: Increase) -> None: - with client.lockboxes.with_streaming_response.update( - lockbox_id="lockbox_3xt21ok13q19advds4t5", + with client.lockbox_recipients.with_streaming_response.update( + lockbox_recipient_id="lockbox_3xt21ok13q19advds4t5", ) as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" - lockbox = response.parse() - assert_matches_type(Lockbox, lockbox, path=["response"]) + lockbox_recipient = response.parse() + assert_matches_type(LockboxRecipient, lockbox_recipient, path=["response"]) assert cast(Any, response.is_closed) is True @parametrize def test_path_params_update(self, client: Increase) -> None: - with pytest.raises(ValueError, match=r"Expected a non-empty value for `lockbox_id` but received ''"): - client.lockboxes.with_raw_response.update( - lockbox_id="", + with pytest.raises(ValueError, match=r"Expected a non-empty value for `lockbox_recipient_id` but received ''"): + client.lockbox_recipients.with_raw_response.update( + lockbox_recipient_id="", ) @parametrize def test_method_list(self, client: Increase) -> None: - lockbox = client.lockboxes.list() - assert_matches_type(SyncPage[Lockbox], lockbox, path=["response"]) + lockbox_recipient = client.lockbox_recipients.list() + assert_matches_type(SyncPage[LockboxRecipient], lockbox_recipient, path=["response"]) @parametrize def test_method_list_with_all_params(self, client: Increase) -> None: - lockbox = client.lockboxes.list( + lockbox_recipient = client.lockbox_recipients.list( account_id="account_id", created_at={ "after": parse_datetime("2019-12-27T18:11:19.117Z"), @@ -163,169 +169,174 @@ def test_method_list_with_all_params(self, client: Increase) -> None: cursor="cursor", idempotency_key="x", limit=1, + lockbox_address_id="lockbox_address_id", ) - assert_matches_type(SyncPage[Lockbox], lockbox, path=["response"]) + assert_matches_type(SyncPage[LockboxRecipient], lockbox_recipient, path=["response"]) @parametrize def test_raw_response_list(self, client: Increase) -> None: - response = client.lockboxes.with_raw_response.list() + response = client.lockbox_recipients.with_raw_response.list() assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" - lockbox = response.parse() - assert_matches_type(SyncPage[Lockbox], lockbox, path=["response"]) + lockbox_recipient = response.parse() + assert_matches_type(SyncPage[LockboxRecipient], lockbox_recipient, path=["response"]) @parametrize def test_streaming_response_list(self, client: Increase) -> None: - with client.lockboxes.with_streaming_response.list() as response: + with client.lockbox_recipients.with_streaming_response.list() as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" - lockbox = response.parse() - assert_matches_type(SyncPage[Lockbox], lockbox, path=["response"]) + lockbox_recipient = response.parse() + assert_matches_type(SyncPage[LockboxRecipient], lockbox_recipient, path=["response"]) assert cast(Any, response.is_closed) is True -class TestAsyncLockboxes: +class TestAsyncLockboxRecipients: parametrize = pytest.mark.parametrize( "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] ) @parametrize async def test_method_create(self, async_client: AsyncIncrease) -> None: - lockbox = await async_client.lockboxes.create( + lockbox_recipient = await async_client.lockbox_recipients.create( account_id="account_in71c4amph0vgo2qllky", + lockbox_address_id="lockbox_address_lw6sbzl9ol5dfd8hdml6", ) - assert_matches_type(Lockbox, lockbox, path=["response"]) + assert_matches_type(LockboxRecipient, lockbox_recipient, path=["response"]) @parametrize async def test_method_create_with_all_params(self, async_client: AsyncIncrease) -> None: - lockbox = await async_client.lockboxes.create( + lockbox_recipient = await async_client.lockbox_recipients.create( account_id="account_in71c4amph0vgo2qllky", - description="Rent payments", - recipient_name="x", + lockbox_address_id="lockbox_address_lw6sbzl9ol5dfd8hdml6", + description="x", + recipient_name="Ian Crease", ) - assert_matches_type(Lockbox, lockbox, path=["response"]) + assert_matches_type(LockboxRecipient, lockbox_recipient, path=["response"]) @parametrize async def test_raw_response_create(self, async_client: AsyncIncrease) -> None: - response = await async_client.lockboxes.with_raw_response.create( + response = await async_client.lockbox_recipients.with_raw_response.create( account_id="account_in71c4amph0vgo2qllky", + lockbox_address_id="lockbox_address_lw6sbzl9ol5dfd8hdml6", ) assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" - lockbox = await response.parse() - assert_matches_type(Lockbox, lockbox, path=["response"]) + lockbox_recipient = await response.parse() + assert_matches_type(LockboxRecipient, lockbox_recipient, path=["response"]) @parametrize async def test_streaming_response_create(self, async_client: AsyncIncrease) -> None: - async with async_client.lockboxes.with_streaming_response.create( + async with async_client.lockbox_recipients.with_streaming_response.create( account_id="account_in71c4amph0vgo2qllky", + lockbox_address_id="lockbox_address_lw6sbzl9ol5dfd8hdml6", ) as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" - lockbox = await response.parse() - assert_matches_type(Lockbox, lockbox, path=["response"]) + lockbox_recipient = await response.parse() + assert_matches_type(LockboxRecipient, lockbox_recipient, path=["response"]) assert cast(Any, response.is_closed) is True @parametrize async def test_method_retrieve(self, async_client: AsyncIncrease) -> None: - lockbox = await async_client.lockboxes.retrieve( + lockbox_recipient = await async_client.lockbox_recipients.retrieve( "lockbox_3xt21ok13q19advds4t5", ) - assert_matches_type(Lockbox, lockbox, path=["response"]) + assert_matches_type(LockboxRecipient, lockbox_recipient, path=["response"]) @parametrize async def test_raw_response_retrieve(self, async_client: AsyncIncrease) -> None: - response = await async_client.lockboxes.with_raw_response.retrieve( + response = await async_client.lockbox_recipients.with_raw_response.retrieve( "lockbox_3xt21ok13q19advds4t5", ) assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" - lockbox = await response.parse() - assert_matches_type(Lockbox, lockbox, path=["response"]) + lockbox_recipient = await response.parse() + assert_matches_type(LockboxRecipient, lockbox_recipient, path=["response"]) @parametrize async def test_streaming_response_retrieve(self, async_client: AsyncIncrease) -> None: - async with async_client.lockboxes.with_streaming_response.retrieve( + async with async_client.lockbox_recipients.with_streaming_response.retrieve( "lockbox_3xt21ok13q19advds4t5", ) as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" - lockbox = await response.parse() - assert_matches_type(Lockbox, lockbox, path=["response"]) + lockbox_recipient = await response.parse() + assert_matches_type(LockboxRecipient, lockbox_recipient, path=["response"]) assert cast(Any, response.is_closed) is True @parametrize async def test_path_params_retrieve(self, async_client: AsyncIncrease) -> None: - with pytest.raises(ValueError, match=r"Expected a non-empty value for `lockbox_id` but received ''"): - await async_client.lockboxes.with_raw_response.retrieve( + with pytest.raises(ValueError, match=r"Expected a non-empty value for `lockbox_recipient_id` but received ''"): + await async_client.lockbox_recipients.with_raw_response.retrieve( "", ) @parametrize async def test_method_update(self, async_client: AsyncIncrease) -> None: - lockbox = await async_client.lockboxes.update( - lockbox_id="lockbox_3xt21ok13q19advds4t5", + lockbox_recipient = await async_client.lockbox_recipients.update( + lockbox_recipient_id="lockbox_3xt21ok13q19advds4t5", ) - assert_matches_type(Lockbox, lockbox, path=["response"]) + assert_matches_type(LockboxRecipient, lockbox_recipient, path=["response"]) @parametrize async def test_method_update_with_all_params(self, async_client: AsyncIncrease) -> None: - lockbox = await async_client.lockboxes.update( - lockbox_id="lockbox_3xt21ok13q19advds4t5", - check_deposit_behavior="disabled", + lockbox_recipient = await async_client.lockbox_recipients.update( + lockbox_recipient_id="lockbox_3xt21ok13q19advds4t5", description="x", recipient_name="x", + status="active", ) - assert_matches_type(Lockbox, lockbox, path=["response"]) + assert_matches_type(LockboxRecipient, lockbox_recipient, path=["response"]) @parametrize async def test_raw_response_update(self, async_client: AsyncIncrease) -> None: - response = await async_client.lockboxes.with_raw_response.update( - lockbox_id="lockbox_3xt21ok13q19advds4t5", + response = await async_client.lockbox_recipients.with_raw_response.update( + lockbox_recipient_id="lockbox_3xt21ok13q19advds4t5", ) assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" - lockbox = await response.parse() - assert_matches_type(Lockbox, lockbox, path=["response"]) + lockbox_recipient = await response.parse() + assert_matches_type(LockboxRecipient, lockbox_recipient, path=["response"]) @parametrize async def test_streaming_response_update(self, async_client: AsyncIncrease) -> None: - async with async_client.lockboxes.with_streaming_response.update( - lockbox_id="lockbox_3xt21ok13q19advds4t5", + async with async_client.lockbox_recipients.with_streaming_response.update( + lockbox_recipient_id="lockbox_3xt21ok13q19advds4t5", ) as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" - lockbox = await response.parse() - assert_matches_type(Lockbox, lockbox, path=["response"]) + lockbox_recipient = await response.parse() + assert_matches_type(LockboxRecipient, lockbox_recipient, path=["response"]) assert cast(Any, response.is_closed) is True @parametrize async def test_path_params_update(self, async_client: AsyncIncrease) -> None: - with pytest.raises(ValueError, match=r"Expected a non-empty value for `lockbox_id` but received ''"): - await async_client.lockboxes.with_raw_response.update( - lockbox_id="", + with pytest.raises(ValueError, match=r"Expected a non-empty value for `lockbox_recipient_id` but received ''"): + await async_client.lockbox_recipients.with_raw_response.update( + lockbox_recipient_id="", ) @parametrize async def test_method_list(self, async_client: AsyncIncrease) -> None: - lockbox = await async_client.lockboxes.list() - assert_matches_type(AsyncPage[Lockbox], lockbox, path=["response"]) + lockbox_recipient = await async_client.lockbox_recipients.list() + assert_matches_type(AsyncPage[LockboxRecipient], lockbox_recipient, path=["response"]) @parametrize async def test_method_list_with_all_params(self, async_client: AsyncIncrease) -> None: - lockbox = await async_client.lockboxes.list( + lockbox_recipient = await async_client.lockbox_recipients.list( account_id="account_id", created_at={ "after": parse_datetime("2019-12-27T18:11:19.117Z"), @@ -336,25 +347,26 @@ async def test_method_list_with_all_params(self, async_client: AsyncIncrease) -> cursor="cursor", idempotency_key="x", limit=1, + lockbox_address_id="lockbox_address_id", ) - assert_matches_type(AsyncPage[Lockbox], lockbox, path=["response"]) + assert_matches_type(AsyncPage[LockboxRecipient], lockbox_recipient, path=["response"]) @parametrize async def test_raw_response_list(self, async_client: AsyncIncrease) -> None: - response = await async_client.lockboxes.with_raw_response.list() + response = await async_client.lockbox_recipients.with_raw_response.list() assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" - lockbox = await response.parse() - assert_matches_type(AsyncPage[Lockbox], lockbox, path=["response"]) + lockbox_recipient = await response.parse() + assert_matches_type(AsyncPage[LockboxRecipient], lockbox_recipient, path=["response"]) @parametrize async def test_streaming_response_list(self, async_client: AsyncIncrease) -> None: - async with async_client.lockboxes.with_streaming_response.list() as response: + async with async_client.lockbox_recipients.with_streaming_response.list() as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" - lockbox = await response.parse() - assert_matches_type(AsyncPage[Lockbox], lockbox, path=["response"]) + lockbox_recipient = await response.parse() + assert_matches_type(AsyncPage[LockboxRecipient], lockbox_recipient, path=["response"]) assert cast(Any, response.is_closed) is True From 515225982d98f7db956a56110c209a78607e3be8 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 27 Apr 2026 16:34:30 +0000 Subject: [PATCH 2/2] release: 0.496.0 --- .release-please-manifest.json | 2 +- CHANGELOG.md | 8 ++++++++ pyproject.toml | 2 +- src/increase/_version.py | 2 +- 4 files changed, 11 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index ed19d2c60..9a47da071 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.495.1" + ".": "0.496.0" } \ No newline at end of file diff --git a/CHANGELOG.md b/CHANGELOG.md index 114717275..8e69542f4 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,13 @@ # Changelog +## 0.496.0 (2026-04-27) + +Full Changelog: [v0.495.1...v0.496.0](https://github.com/Increase/increase-python/compare/v0.495.1...v0.496.0) + +### Features + +* **api:** api update ([73363ff](https://github.com/Increase/increase-python/commit/73363ff764d6e305318dec07121d4e4b36c3bde2)) + ## 0.495.1 (2026-04-27) Full Changelog: [v0.495.0...v0.495.1](https://github.com/Increase/increase-python/compare/v0.495.0...v0.495.1) diff --git a/pyproject.toml b/pyproject.toml index 8c4e6e88a..9d757de90 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "increase" -version = "0.495.1" +version = "0.496.0" description = "The official Python library for the increase API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/increase/_version.py b/src/increase/_version.py index a7c9346de..7277d6c32 100644 --- a/src/increase/_version.py +++ b/src/increase/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "increase" -__version__ = "0.495.1" # x-release-please-version +__version__ = "0.496.0" # x-release-please-version