diff --git a/.release-please-manifest.json b/.release-please-manifest.json index 3f3a2fc4..45f59399 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.473.1" + ".": "0.474.0" } \ No newline at end of file diff --git a/.stats.yml b/.stats.yml index 8e99a7e6..cc2badb6 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ -configured_endpoints: 236 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/increase%2Fincrease-07202bc3c027c441ab8829ab0e32c1547952d4cae1691fe00497ee3b056127d0.yml -openapi_spec_hash: 3c21b26cf5803678876c00c40e88c781 -config_hash: 4945e03affdf289484733306e4797f81 +configured_endpoints: 241 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/increase%2Fincrease-8bbf0093efa65975131da3735f2adc0ec05432cde8c05e9c9796bc7d553103ae.yml +openapi_spec_hash: 5080ba849a5b100ace3bec9da24d4dc7 +config_hash: d48e9f65bcf642f92610034d6c43f07a diff --git a/CHANGELOG.md b/CHANGELOG.md index d29386bd..0bdff390 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,13 @@ # Changelog +## 0.474.0 (2026-04-09) + +Full Changelog: [v0.473.1...v0.474.0](https://github.com/Increase/increase-python/compare/v0.473.1...v0.474.0) + +### Features + +* **api:** api update ([4d083a9](https://github.com/Increase/increase-python/commit/4d083a980a7b07e557b7eb6ea9a3e511963fefcb)) + ## 0.473.1 (2026-04-07) Full Changelog: [v0.473.0...v0.473.1](https://github.com/Increase/increase-python/compare/v0.473.0...v0.473.1) diff --git a/api.md b/api.md index 0d68ea18..a3952130 100644 --- a/api.md +++ b/api.md @@ -531,6 +531,21 @@ Methods: - client.supplemental_documents.create(\*\*params) -> EntitySupplementalDocument - client.supplemental_documents.list(\*\*params) -> SyncPage[EntitySupplementalDocument] +# EntityOnboardingSessions + +Types: + +```python +from increase.types import EntityOnboardingSession +``` + +Methods: + +- client.entity_onboarding_sessions.create(\*\*params) -> EntityOnboardingSession +- client.entity_onboarding_sessions.retrieve(entity_onboarding_session_id) -> EntityOnboardingSession +- client.entity_onboarding_sessions.list(\*\*params) -> SyncPage[EntityOnboardingSession] +- client.entity_onboarding_sessions.expire(entity_onboarding_session_id) -> EntityOnboardingSession + # Programs Types: @@ -1011,6 +1026,12 @@ Methods: - client.simulations.inbound_mail_items.create(\*\*params) -> InboundMailItem +## EntityOnboardingSessions + +Methods: + +- client.simulations.entity_onboarding_sessions.submit(entity_onboarding_session_id) -> EntityOnboardingSession + ## Programs Methods: diff --git a/pyproject.toml b/pyproject.toml index 08327a2a..2597ee17 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "increase" -version = "0.473.1" +version = "0.474.0" description = "The official Python library for the increase API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/increase/_client.py b/src/increase/_client.py index e6b53fe2..49280b23 100644 --- a/src/increase/_client.py +++ b/src/increase/_client.py @@ -90,6 +90,7 @@ wire_drawdown_requests, inbound_fednow_transfers, card_purchase_supplements, + entity_onboarding_sessions, intrafi_account_enrollments, real_time_payments_transfers, inbound_wire_drawdown_requests, @@ -152,6 +153,10 @@ CardPurchaseSupplementsResource, AsyncCardPurchaseSupplementsResource, ) + from .resources.entity_onboarding_sessions import ( + EntityOnboardingSessionsResource, + AsyncEntityOnboardingSessionsResource, + ) from .resources.intrafi_account_enrollments import ( IntrafiAccountEnrollmentsResource, AsyncIntrafiAccountEnrollmentsResource, @@ -492,6 +497,12 @@ def supplemental_documents(self) -> SupplementalDocumentsResource: return SupplementalDocumentsResource(self) + @cached_property + def entity_onboarding_sessions(self) -> EntityOnboardingSessionsResource: + from .resources.entity_onboarding_sessions import EntityOnboardingSessionsResource + + return EntityOnboardingSessionsResource(self) + @cached_property def programs(self) -> ProgramsResource: from .resources.programs import ProgramsResource @@ -1091,6 +1102,12 @@ def supplemental_documents(self) -> AsyncSupplementalDocumentsResource: return AsyncSupplementalDocumentsResource(self) + @cached_property + def entity_onboarding_sessions(self) -> AsyncEntityOnboardingSessionsResource: + from .resources.entity_onboarding_sessions import AsyncEntityOnboardingSessionsResource + + return AsyncEntityOnboardingSessionsResource(self) + @cached_property def programs(self) -> AsyncProgramsResource: from .resources.programs import AsyncProgramsResource @@ -1617,6 +1634,12 @@ def supplemental_documents(self) -> supplemental_documents.SupplementalDocuments return SupplementalDocumentsResourceWithRawResponse(self._client.supplemental_documents) + @cached_property + def entity_onboarding_sessions(self) -> entity_onboarding_sessions.EntityOnboardingSessionsResourceWithRawResponse: + from .resources.entity_onboarding_sessions import EntityOnboardingSessionsResourceWithRawResponse + + return EntityOnboardingSessionsResourceWithRawResponse(self._client.entity_onboarding_sessions) + @cached_property def programs(self) -> programs.ProgramsResourceWithRawResponse: from .resources.programs import ProgramsResourceWithRawResponse @@ -1986,6 +2009,14 @@ def supplemental_documents(self) -> supplemental_documents.AsyncSupplementalDocu return AsyncSupplementalDocumentsResourceWithRawResponse(self._client.supplemental_documents) + @cached_property + def entity_onboarding_sessions( + self, + ) -> entity_onboarding_sessions.AsyncEntityOnboardingSessionsResourceWithRawResponse: + from .resources.entity_onboarding_sessions import AsyncEntityOnboardingSessionsResourceWithRawResponse + + return AsyncEntityOnboardingSessionsResourceWithRawResponse(self._client.entity_onboarding_sessions) + @cached_property def programs(self) -> programs.AsyncProgramsResourceWithRawResponse: from .resources.programs import AsyncProgramsResourceWithRawResponse @@ -2355,6 +2386,14 @@ def supplemental_documents(self) -> supplemental_documents.SupplementalDocuments return SupplementalDocumentsResourceWithStreamingResponse(self._client.supplemental_documents) + @cached_property + def entity_onboarding_sessions( + self, + ) -> entity_onboarding_sessions.EntityOnboardingSessionsResourceWithStreamingResponse: + from .resources.entity_onboarding_sessions import EntityOnboardingSessionsResourceWithStreamingResponse + + return EntityOnboardingSessionsResourceWithStreamingResponse(self._client.entity_onboarding_sessions) + @cached_property def programs(self) -> programs.ProgramsResourceWithStreamingResponse: from .resources.programs import ProgramsResourceWithStreamingResponse @@ -2730,6 +2769,14 @@ def supplemental_documents(self) -> supplemental_documents.AsyncSupplementalDocu return AsyncSupplementalDocumentsResourceWithStreamingResponse(self._client.supplemental_documents) + @cached_property + def entity_onboarding_sessions( + self, + ) -> entity_onboarding_sessions.AsyncEntityOnboardingSessionsResourceWithStreamingResponse: + from .resources.entity_onboarding_sessions import AsyncEntityOnboardingSessionsResourceWithStreamingResponse + + return AsyncEntityOnboardingSessionsResourceWithStreamingResponse(self._client.entity_onboarding_sessions) + @cached_property def programs(self) -> programs.AsyncProgramsResourceWithStreamingResponse: from .resources.programs import AsyncProgramsResourceWithStreamingResponse diff --git a/src/increase/_version.py b/src/increase/_version.py index 8ccdb40f..23dddbf3 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.473.1" # x-release-please-version +__version__ = "0.474.0" # x-release-please-version diff --git a/src/increase/resources/__init__.py b/src/increase/resources/__init__.py index d62d8ae4..192bfb62 100644 --- a/src/increase/resources/__init__.py +++ b/src/increase/resources/__init__.py @@ -432,6 +432,14 @@ CardPurchaseSupplementsResourceWithStreamingResponse, AsyncCardPurchaseSupplementsResourceWithStreamingResponse, ) +from .entity_onboarding_sessions import ( + EntityOnboardingSessionsResource, + AsyncEntityOnboardingSessionsResource, + EntityOnboardingSessionsResourceWithRawResponse, + AsyncEntityOnboardingSessionsResourceWithRawResponse, + EntityOnboardingSessionsResourceWithStreamingResponse, + AsyncEntityOnboardingSessionsResourceWithStreamingResponse, +) from .intrafi_account_enrollments import ( IntrafiAccountEnrollmentsResource, AsyncIntrafiAccountEnrollmentsResource, @@ -682,6 +690,12 @@ "AsyncSupplementalDocumentsResourceWithRawResponse", "SupplementalDocumentsResourceWithStreamingResponse", "AsyncSupplementalDocumentsResourceWithStreamingResponse", + "EntityOnboardingSessionsResource", + "AsyncEntityOnboardingSessionsResource", + "EntityOnboardingSessionsResourceWithRawResponse", + "AsyncEntityOnboardingSessionsResourceWithRawResponse", + "EntityOnboardingSessionsResourceWithStreamingResponse", + "AsyncEntityOnboardingSessionsResourceWithStreamingResponse", "ProgramsResource", "AsyncProgramsResource", "ProgramsResourceWithRawResponse", diff --git a/src/increase/resources/entity_onboarding_sessions.py b/src/increase/resources/entity_onboarding_sessions.py new file mode 100644 index 00000000..bc315a87 --- /dev/null +++ b/src/increase/resources/entity_onboarding_sessions.py @@ -0,0 +1,540 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +import httpx + +from ..types import entity_onboarding_session_list_params, entity_onboarding_session_create_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.entity_onboarding_session import EntityOnboardingSession + +__all__ = ["EntityOnboardingSessionsResource", "AsyncEntityOnboardingSessionsResource"] + + +class EntityOnboardingSessionsResource(SyncAPIResource): + @cached_property + def with_raw_response(self) -> EntityOnboardingSessionsResourceWithRawResponse: + """ + 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 EntityOnboardingSessionsResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> EntityOnboardingSessionsResourceWithStreamingResponse: + """ + 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 EntityOnboardingSessionsResourceWithStreamingResponse(self) + + def create( + self, + *, + program_id: str, + redirect_url: str, + entity_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, + idempotency_key: str | None = None, + ) -> EntityOnboardingSession: + """ + Create an Entity Onboarding Session + + Args: + program_id: The identifier of the Program the Entity will be onboarded to. + + redirect_url: The URL to redirect the customer to after they complete the onboarding form. The + redirect will include `entity_onboarding_session_id` and `entity_id` query + parameters. + + entity_id: The identifier of an existing Entity to associate with the onboarding session. + If provided, the onboarding form will display any outstanding tasks required to + complete the Entity's onboarding. + + 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( + "/entity_onboarding_sessions", + body=maybe_transform( + { + "program_id": program_id, + "redirect_url": redirect_url, + "entity_id": entity_id, + }, + entity_onboarding_session_create_params.EntityOnboardingSessionCreateParams, + ), + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + idempotency_key=idempotency_key, + ), + cast_to=EntityOnboardingSession, + ) + + def retrieve( + self, + entity_onboarding_session_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, + ) -> EntityOnboardingSession: + """ + Retrieve an Entity Onboarding Session + + Args: + entity_onboarding_session_id: The identifier of the Entity Onboarding Session. + + 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 entity_onboarding_session_id: + raise ValueError( + f"Expected a non-empty value for `entity_onboarding_session_id` but received {entity_onboarding_session_id!r}" + ) + return self._get( + path_template( + "/entity_onboarding_sessions/{entity_onboarding_session_id}", + entity_onboarding_session_id=entity_onboarding_session_id, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=EntityOnboardingSession, + ) + + def list( + self, + *, + cursor: str | Omit = omit, + idempotency_key: str | Omit = omit, + limit: int | Omit = omit, + status: entity_onboarding_session_list_params.Status | 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[EntityOnboardingSession]: + """ + List Entity Onboarding Session + + Args: + 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. + + 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( + "/entity_onboarding_sessions", + page=SyncPage[EntityOnboardingSession], + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=maybe_transform( + { + "cursor": cursor, + "idempotency_key": idempotency_key, + "limit": limit, + "status": status, + }, + entity_onboarding_session_list_params.EntityOnboardingSessionListParams, + ), + ), + model=EntityOnboardingSession, + ) + + def expire( + self, + entity_onboarding_session_id: str, + *, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + idempotency_key: str | None = None, + ) -> EntityOnboardingSession: + """ + Expire an Entity Onboarding Session + + Args: + entity_onboarding_session_id: The identifier of the Entity Onboarding Session to expire. + + 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 entity_onboarding_session_id: + raise ValueError( + f"Expected a non-empty value for `entity_onboarding_session_id` but received {entity_onboarding_session_id!r}" + ) + return self._post( + path_template( + "/entity_onboarding_sessions/{entity_onboarding_session_id}/expire", + entity_onboarding_session_id=entity_onboarding_session_id, + ), + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + idempotency_key=idempotency_key, + ), + cast_to=EntityOnboardingSession, + ) + + +class AsyncEntityOnboardingSessionsResource(AsyncAPIResource): + @cached_property + def with_raw_response(self) -> AsyncEntityOnboardingSessionsResourceWithRawResponse: + """ + 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 AsyncEntityOnboardingSessionsResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncEntityOnboardingSessionsResourceWithStreamingResponse: + """ + 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 AsyncEntityOnboardingSessionsResourceWithStreamingResponse(self) + + async def create( + self, + *, + program_id: str, + redirect_url: str, + entity_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, + idempotency_key: str | None = None, + ) -> EntityOnboardingSession: + """ + Create an Entity Onboarding Session + + Args: + program_id: The identifier of the Program the Entity will be onboarded to. + + redirect_url: The URL to redirect the customer to after they complete the onboarding form. The + redirect will include `entity_onboarding_session_id` and `entity_id` query + parameters. + + entity_id: The identifier of an existing Entity to associate with the onboarding session. + If provided, the onboarding form will display any outstanding tasks required to + complete the Entity's onboarding. + + 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( + "/entity_onboarding_sessions", + body=await async_maybe_transform( + { + "program_id": program_id, + "redirect_url": redirect_url, + "entity_id": entity_id, + }, + entity_onboarding_session_create_params.EntityOnboardingSessionCreateParams, + ), + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + idempotency_key=idempotency_key, + ), + cast_to=EntityOnboardingSession, + ) + + async def retrieve( + self, + entity_onboarding_session_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, + ) -> EntityOnboardingSession: + """ + Retrieve an Entity Onboarding Session + + Args: + entity_onboarding_session_id: The identifier of the Entity Onboarding Session. + + 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 entity_onboarding_session_id: + raise ValueError( + f"Expected a non-empty value for `entity_onboarding_session_id` but received {entity_onboarding_session_id!r}" + ) + return await self._get( + path_template( + "/entity_onboarding_sessions/{entity_onboarding_session_id}", + entity_onboarding_session_id=entity_onboarding_session_id, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=EntityOnboardingSession, + ) + + def list( + self, + *, + cursor: str | Omit = omit, + idempotency_key: str | Omit = omit, + limit: int | Omit = omit, + status: entity_onboarding_session_list_params.Status | 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[EntityOnboardingSession, AsyncPage[EntityOnboardingSession]]: + """ + List Entity Onboarding Session + + Args: + 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. + + 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( + "/entity_onboarding_sessions", + page=AsyncPage[EntityOnboardingSession], + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=maybe_transform( + { + "cursor": cursor, + "idempotency_key": idempotency_key, + "limit": limit, + "status": status, + }, + entity_onboarding_session_list_params.EntityOnboardingSessionListParams, + ), + ), + model=EntityOnboardingSession, + ) + + async def expire( + self, + entity_onboarding_session_id: str, + *, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + idempotency_key: str | None = None, + ) -> EntityOnboardingSession: + """ + Expire an Entity Onboarding Session + + Args: + entity_onboarding_session_id: The identifier of the Entity Onboarding Session to expire. + + 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 entity_onboarding_session_id: + raise ValueError( + f"Expected a non-empty value for `entity_onboarding_session_id` but received {entity_onboarding_session_id!r}" + ) + return await self._post( + path_template( + "/entity_onboarding_sessions/{entity_onboarding_session_id}/expire", + entity_onboarding_session_id=entity_onboarding_session_id, + ), + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + idempotency_key=idempotency_key, + ), + cast_to=EntityOnboardingSession, + ) + + +class EntityOnboardingSessionsResourceWithRawResponse: + def __init__(self, entity_onboarding_sessions: EntityOnboardingSessionsResource) -> None: + self._entity_onboarding_sessions = entity_onboarding_sessions + + self.create = to_raw_response_wrapper( + entity_onboarding_sessions.create, + ) + self.retrieve = to_raw_response_wrapper( + entity_onboarding_sessions.retrieve, + ) + self.list = to_raw_response_wrapper( + entity_onboarding_sessions.list, + ) + self.expire = to_raw_response_wrapper( + entity_onboarding_sessions.expire, + ) + + +class AsyncEntityOnboardingSessionsResourceWithRawResponse: + def __init__(self, entity_onboarding_sessions: AsyncEntityOnboardingSessionsResource) -> None: + self._entity_onboarding_sessions = entity_onboarding_sessions + + self.create = async_to_raw_response_wrapper( + entity_onboarding_sessions.create, + ) + self.retrieve = async_to_raw_response_wrapper( + entity_onboarding_sessions.retrieve, + ) + self.list = async_to_raw_response_wrapper( + entity_onboarding_sessions.list, + ) + self.expire = async_to_raw_response_wrapper( + entity_onboarding_sessions.expire, + ) + + +class EntityOnboardingSessionsResourceWithStreamingResponse: + def __init__(self, entity_onboarding_sessions: EntityOnboardingSessionsResource) -> None: + self._entity_onboarding_sessions = entity_onboarding_sessions + + self.create = to_streamed_response_wrapper( + entity_onboarding_sessions.create, + ) + self.retrieve = to_streamed_response_wrapper( + entity_onboarding_sessions.retrieve, + ) + self.list = to_streamed_response_wrapper( + entity_onboarding_sessions.list, + ) + self.expire = to_streamed_response_wrapper( + entity_onboarding_sessions.expire, + ) + + +class AsyncEntityOnboardingSessionsResourceWithStreamingResponse: + def __init__(self, entity_onboarding_sessions: AsyncEntityOnboardingSessionsResource) -> None: + self._entity_onboarding_sessions = entity_onboarding_sessions + + self.create = async_to_streamed_response_wrapper( + entity_onboarding_sessions.create, + ) + self.retrieve = async_to_streamed_response_wrapper( + entity_onboarding_sessions.retrieve, + ) + self.list = async_to_streamed_response_wrapper( + entity_onboarding_sessions.list, + ) + self.expire = async_to_streamed_response_wrapper( + entity_onboarding_sessions.expire, + ) diff --git a/src/increase/resources/simulations/__init__.py b/src/increase/resources/simulations/__init__.py index 972e5b7b..b3c198a7 100644 --- a/src/increase/resources/simulations/__init__.py +++ b/src/increase/resources/simulations/__init__.py @@ -224,6 +224,14 @@ InboundFednowTransfersResourceWithStreamingResponse, AsyncInboundFednowTransfersResourceWithStreamingResponse, ) +from .entity_onboarding_sessions import ( + EntityOnboardingSessionsResource, + AsyncEntityOnboardingSessionsResource, + EntityOnboardingSessionsResourceWithRawResponse, + AsyncEntityOnboardingSessionsResourceWithRawResponse, + EntityOnboardingSessionsResourceWithStreamingResponse, + AsyncEntityOnboardingSessionsResourceWithStreamingResponse, +) from .real_time_payments_transfers import ( RealTimePaymentsTransfersResource, AsyncRealTimePaymentsTransfersResource, @@ -434,6 +442,12 @@ "AsyncInboundMailItemsResourceWithRawResponse", "InboundMailItemsResourceWithStreamingResponse", "AsyncInboundMailItemsResourceWithStreamingResponse", + "EntityOnboardingSessionsResource", + "AsyncEntityOnboardingSessionsResource", + "EntityOnboardingSessionsResourceWithRawResponse", + "AsyncEntityOnboardingSessionsResourceWithRawResponse", + "EntityOnboardingSessionsResourceWithStreamingResponse", + "AsyncEntityOnboardingSessionsResourceWithStreamingResponse", "ProgramsResource", "AsyncProgramsResource", "ProgramsResourceWithRawResponse", diff --git a/src/increase/resources/simulations/entity_onboarding_sessions.py b/src/increase/resources/simulations/entity_onboarding_sessions.py new file mode 100644 index 00000000..102b851e --- /dev/null +++ b/src/increase/resources/simulations/entity_onboarding_sessions.py @@ -0,0 +1,198 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +import httpx + +from ..._types import Body, Query, Headers, NotGiven, not_given +from ..._utils import path_template +from ..._compat import cached_property +from ..._resource import SyncAPIResource, AsyncAPIResource +from ..._response import ( + to_raw_response_wrapper, + to_streamed_response_wrapper, + async_to_raw_response_wrapper, + async_to_streamed_response_wrapper, +) +from ..._base_client import make_request_options +from ...types.entity_onboarding_session import EntityOnboardingSession + +__all__ = ["EntityOnboardingSessionsResource", "AsyncEntityOnboardingSessionsResource"] + + +class EntityOnboardingSessionsResource(SyncAPIResource): + @cached_property + def with_raw_response(self) -> EntityOnboardingSessionsResourceWithRawResponse: + """ + 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 EntityOnboardingSessionsResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> EntityOnboardingSessionsResourceWithStreamingResponse: + """ + 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 EntityOnboardingSessionsResourceWithStreamingResponse(self) + + def submit( + self, + entity_onboarding_session_id: str, + *, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + idempotency_key: str | None = None, + ) -> EntityOnboardingSession: + """ + Simulates the submission of an + [Entity Onboarding Session](#entity-onboarding-sessions). This session must have + a `status` of `active`. After submission, the session will transition to + `expired` and a new Entity will be created. + + Args: + entity_onboarding_session_id: The identifier of the Entity Onboarding Session you wish to submit. + + 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 entity_onboarding_session_id: + raise ValueError( + f"Expected a non-empty value for `entity_onboarding_session_id` but received {entity_onboarding_session_id!r}" + ) + return self._post( + path_template( + "/simulations/entity_onboarding_sessions/{entity_onboarding_session_id}/submit", + entity_onboarding_session_id=entity_onboarding_session_id, + ), + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + idempotency_key=idempotency_key, + ), + cast_to=EntityOnboardingSession, + ) + + +class AsyncEntityOnboardingSessionsResource(AsyncAPIResource): + @cached_property + def with_raw_response(self) -> AsyncEntityOnboardingSessionsResourceWithRawResponse: + """ + 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 AsyncEntityOnboardingSessionsResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncEntityOnboardingSessionsResourceWithStreamingResponse: + """ + 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 AsyncEntityOnboardingSessionsResourceWithStreamingResponse(self) + + async def submit( + self, + entity_onboarding_session_id: str, + *, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + idempotency_key: str | None = None, + ) -> EntityOnboardingSession: + """ + Simulates the submission of an + [Entity Onboarding Session](#entity-onboarding-sessions). This session must have + a `status` of `active`. After submission, the session will transition to + `expired` and a new Entity will be created. + + Args: + entity_onboarding_session_id: The identifier of the Entity Onboarding Session you wish to submit. + + 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 entity_onboarding_session_id: + raise ValueError( + f"Expected a non-empty value for `entity_onboarding_session_id` but received {entity_onboarding_session_id!r}" + ) + return await self._post( + path_template( + "/simulations/entity_onboarding_sessions/{entity_onboarding_session_id}/submit", + entity_onboarding_session_id=entity_onboarding_session_id, + ), + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + idempotency_key=idempotency_key, + ), + cast_to=EntityOnboardingSession, + ) + + +class EntityOnboardingSessionsResourceWithRawResponse: + def __init__(self, entity_onboarding_sessions: EntityOnboardingSessionsResource) -> None: + self._entity_onboarding_sessions = entity_onboarding_sessions + + self.submit = to_raw_response_wrapper( + entity_onboarding_sessions.submit, + ) + + +class AsyncEntityOnboardingSessionsResourceWithRawResponse: + def __init__(self, entity_onboarding_sessions: AsyncEntityOnboardingSessionsResource) -> None: + self._entity_onboarding_sessions = entity_onboarding_sessions + + self.submit = async_to_raw_response_wrapper( + entity_onboarding_sessions.submit, + ) + + +class EntityOnboardingSessionsResourceWithStreamingResponse: + def __init__(self, entity_onboarding_sessions: EntityOnboardingSessionsResource) -> None: + self._entity_onboarding_sessions = entity_onboarding_sessions + + self.submit = to_streamed_response_wrapper( + entity_onboarding_sessions.submit, + ) + + +class AsyncEntityOnboardingSessionsResourceWithStreamingResponse: + def __init__(self, entity_onboarding_sessions: AsyncEntityOnboardingSessionsResource) -> None: + self._entity_onboarding_sessions = entity_onboarding_sessions + + self.submit = async_to_streamed_response_wrapper( + entity_onboarding_sessions.submit, + ) diff --git a/src/increase/resources/simulations/simulations.py b/src/increase/resources/simulations/simulations.py index 3720f6d5..3051441c 100644 --- a/src/increase/resources/simulations/simulations.py +++ b/src/increase/resources/simulations/simulations.py @@ -220,6 +220,14 @@ InboundFednowTransfersResourceWithStreamingResponse, AsyncInboundFednowTransfersResourceWithStreamingResponse, ) +from .entity_onboarding_sessions import ( + EntityOnboardingSessionsResource, + AsyncEntityOnboardingSessionsResource, + EntityOnboardingSessionsResourceWithRawResponse, + AsyncEntityOnboardingSessionsResourceWithRawResponse, + EntityOnboardingSessionsResourceWithStreamingResponse, + AsyncEntityOnboardingSessionsResourceWithStreamingResponse, +) from .real_time_payments_transfers import ( RealTimePaymentsTransfersResource, AsyncRealTimePaymentsTransfersResource, @@ -377,6 +385,10 @@ def check_deposits(self) -> CheckDepositsResource: def inbound_mail_items(self) -> InboundMailItemsResource: return InboundMailItemsResource(self._client) + @cached_property + def entity_onboarding_sessions(self) -> EntityOnboardingSessionsResource: + return EntityOnboardingSessionsResource(self._client) + @cached_property def programs(self) -> ProgramsResource: return ProgramsResource(self._client) @@ -526,6 +538,10 @@ def check_deposits(self) -> AsyncCheckDepositsResource: def inbound_mail_items(self) -> AsyncInboundMailItemsResource: return AsyncInboundMailItemsResource(self._client) + @cached_property + def entity_onboarding_sessions(self) -> AsyncEntityOnboardingSessionsResource: + return AsyncEntityOnboardingSessionsResource(self._client) + @cached_property def programs(self) -> AsyncProgramsResource: return AsyncProgramsResource(self._client) @@ -680,6 +696,10 @@ def check_deposits(self) -> CheckDepositsResourceWithRawResponse: def inbound_mail_items(self) -> InboundMailItemsResourceWithRawResponse: return InboundMailItemsResourceWithRawResponse(self._simulations.inbound_mail_items) + @cached_property + def entity_onboarding_sessions(self) -> EntityOnboardingSessionsResourceWithRawResponse: + return EntityOnboardingSessionsResourceWithRawResponse(self._simulations.entity_onboarding_sessions) + @cached_property def programs(self) -> ProgramsResourceWithRawResponse: return ProgramsResourceWithRawResponse(self._simulations.programs) @@ -817,6 +837,10 @@ def check_deposits(self) -> AsyncCheckDepositsResourceWithRawResponse: def inbound_mail_items(self) -> AsyncInboundMailItemsResourceWithRawResponse: return AsyncInboundMailItemsResourceWithRawResponse(self._simulations.inbound_mail_items) + @cached_property + def entity_onboarding_sessions(self) -> AsyncEntityOnboardingSessionsResourceWithRawResponse: + return AsyncEntityOnboardingSessionsResourceWithRawResponse(self._simulations.entity_onboarding_sessions) + @cached_property def programs(self) -> AsyncProgramsResourceWithRawResponse: return AsyncProgramsResourceWithRawResponse(self._simulations.programs) @@ -956,6 +980,10 @@ def check_deposits(self) -> CheckDepositsResourceWithStreamingResponse: def inbound_mail_items(self) -> InboundMailItemsResourceWithStreamingResponse: return InboundMailItemsResourceWithStreamingResponse(self._simulations.inbound_mail_items) + @cached_property + def entity_onboarding_sessions(self) -> EntityOnboardingSessionsResourceWithStreamingResponse: + return EntityOnboardingSessionsResourceWithStreamingResponse(self._simulations.entity_onboarding_sessions) + @cached_property def programs(self) -> ProgramsResourceWithStreamingResponse: return ProgramsResourceWithStreamingResponse(self._simulations.programs) @@ -1101,6 +1129,10 @@ def check_deposits(self) -> AsyncCheckDepositsResourceWithStreamingResponse: def inbound_mail_items(self) -> AsyncInboundMailItemsResourceWithStreamingResponse: return AsyncInboundMailItemsResourceWithStreamingResponse(self._simulations.inbound_mail_items) + @cached_property + def entity_onboarding_sessions(self) -> AsyncEntityOnboardingSessionsResourceWithStreamingResponse: + return AsyncEntityOnboardingSessionsResourceWithStreamingResponse(self._simulations.entity_onboarding_sessions) + @cached_property def programs(self) -> AsyncProgramsResourceWithStreamingResponse: return AsyncProgramsResourceWithStreamingResponse(self._simulations.programs) diff --git a/src/increase/types/__init__.py b/src/increase/types/__init__.py index 994a8c3d..9ff68547 100644 --- a/src/increase/types/__init__.py +++ b/src/increase/types/__init__.py @@ -85,6 +85,7 @@ from .card_payment_list_params import CardPaymentListParams as CardPaymentListParams from .card_purchase_supplement import CardPurchaseSupplement as CardPurchaseSupplement from .check_deposit_list_params import CheckDepositListParams as CheckDepositListParams +from .entity_onboarding_session import EntityOnboardingSession as EntityOnboardingSession from .oauth_token_create_params import OAuthTokenCreateParams as OAuthTokenCreateParams from .physical_card_list_params import PhysicalCardListParams as PhysicalCardListParams from .wire_transfer_list_params import WireTransferListParams as WireTransferListParams @@ -168,9 +169,15 @@ from .wire_drawdown_request_create_params import WireDrawdownRequestCreateParams as WireDrawdownRequestCreateParams from .card_purchase_supplement_list_params import CardPurchaseSupplementListParams as CardPurchaseSupplementListParams from .inbound_wire_transfer_reverse_params import InboundWireTransferReverseParams as InboundWireTransferReverseParams +from .entity_onboarding_session_list_params import ( + EntityOnboardingSessionListParams as EntityOnboardingSessionListParams, +) from .intrafi_account_enrollment_list_params import ( IntrafiAccountEnrollmentListParams as IntrafiAccountEnrollmentListParams, ) +from .entity_onboarding_session_create_params import ( + EntityOnboardingSessionCreateParams as EntityOnboardingSessionCreateParams, +) from .real_time_payments_transfer_list_params import ( RealTimePaymentsTransferListParams as RealTimePaymentsTransferListParams, ) diff --git a/src/increase/types/entity_onboarding_session.py b/src/increase/types/entity_onboarding_session.py new file mode 100644 index 00000000..97ab25e7 --- /dev/null +++ b/src/increase/types/entity_onboarding_session.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__ = ["EntityOnboardingSession"] + + +class EntityOnboardingSession(BaseModel): + """ + Entity Onboarding Sessions let your customers onboard themselves by completing Increase-hosted forms. Create a session and redirect your customer to the returned URL. When they're done, they'll be redirected back to your site. This API is used for [hosted onboarding](/documentation/hosted-onboarding). + """ + + id: str + """The Entity Onboarding Session's identifier.""" + + created_at: datetime + """ + The [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date and time at which + the Entity Onboarding Session was created. + """ + + entity_id: Optional[str] = None + """ + The identifier of the Entity associated with this session, if one has been + created or was provided when creating the session. + """ + + expires_at: datetime + """ + The [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date and time at which + the Entity Onboarding Session will expire. + """ + + 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). + """ + + program_id: str + """The identifier of the Program the Entity will be onboarded to.""" + + redirect_url: str + """The URL to redirect to after the onboarding session is complete. + + Increase will include the query parameters `entity_onboarding_session_id` and + `entity_id` when redirecting. + """ + + session_url: Optional[str] = None + """The URL containing the onboarding form. + + You should share this link with your customer. Only present when the session is + active. + """ + + status: Literal["active", "expired"] + """The status of the onboarding session. + + - `active` - The Entity Onboarding Session is active. + - `expired` - The Entity Onboarding Session has expired. + """ + + type: Literal["entity_onboarding_session"] + """A constant representing the object's type. + + For this resource it will always be `entity_onboarding_session`. + """ diff --git a/src/increase/types/entity_onboarding_session_create_params.py b/src/increase/types/entity_onboarding_session_create_params.py new file mode 100644 index 00000000..6ccf843d --- /dev/null +++ b/src/increase/types/entity_onboarding_session_create_params.py @@ -0,0 +1,26 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing_extensions import Required, TypedDict + +__all__ = ["EntityOnboardingSessionCreateParams"] + + +class EntityOnboardingSessionCreateParams(TypedDict, total=False): + program_id: Required[str] + """The identifier of the Program the Entity will be onboarded to.""" + + redirect_url: Required[str] + """The URL to redirect the customer to after they complete the onboarding form. + + The redirect will include `entity_onboarding_session_id` and `entity_id` query + parameters. + """ + + entity_id: str + """The identifier of an existing Entity to associate with the onboarding session. + + If provided, the onboarding form will display any outstanding tasks required to + complete the Entity's onboarding. + """ diff --git a/src/increase/types/entity_onboarding_session_list_params.py b/src/increase/types/entity_onboarding_session_list_params.py new file mode 100644 index 00000000..96c5d017 --- /dev/null +++ b/src/increase/types/entity_onboarding_session_list_params.py @@ -0,0 +1,42 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import List +from typing_extensions import Literal, TypedDict + +__all__ = ["EntityOnboardingSessionListParams", "Status"] + + +class EntityOnboardingSessionListParams(TypedDict, total=False): + 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. + """ + + status: Status + + +_StatusReservedKeywords = TypedDict( + "_StatusReservedKeywords", + { + "in": List[Literal["active", "expired"]], + }, + total=False, +) + + +class Status(_StatusReservedKeywords, total=False): + pass diff --git a/tests/api_resources/simulations/test_entity_onboarding_sessions.py b/tests/api_resources/simulations/test_entity_onboarding_sessions.py new file mode 100644 index 00000000..17cf8426 --- /dev/null +++ b/tests/api_resources/simulations/test_entity_onboarding_sessions.py @@ -0,0 +1,104 @@ +# 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 EntityOnboardingSession + +base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") + + +class TestEntityOnboardingSessions: + parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) + + @parametrize + def test_method_submit(self, client: Increase) -> None: + entity_onboarding_session = client.simulations.entity_onboarding_sessions.submit( + "entity_onboarding_session_wid2ug11fsmvh3k9hymd", + ) + assert_matches_type(EntityOnboardingSession, entity_onboarding_session, path=["response"]) + + @parametrize + def test_raw_response_submit(self, client: Increase) -> None: + response = client.simulations.entity_onboarding_sessions.with_raw_response.submit( + "entity_onboarding_session_wid2ug11fsmvh3k9hymd", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + entity_onboarding_session = response.parse() + assert_matches_type(EntityOnboardingSession, entity_onboarding_session, path=["response"]) + + @parametrize + def test_streaming_response_submit(self, client: Increase) -> None: + with client.simulations.entity_onboarding_sessions.with_streaming_response.submit( + "entity_onboarding_session_wid2ug11fsmvh3k9hymd", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + entity_onboarding_session = response.parse() + assert_matches_type(EntityOnboardingSession, entity_onboarding_session, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_path_params_submit(self, client: Increase) -> None: + with pytest.raises( + ValueError, match=r"Expected a non-empty value for `entity_onboarding_session_id` but received ''" + ): + client.simulations.entity_onboarding_sessions.with_raw_response.submit( + "", + ) + + +class TestAsyncEntityOnboardingSessions: + parametrize = pytest.mark.parametrize( + "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] + ) + + @parametrize + async def test_method_submit(self, async_client: AsyncIncrease) -> None: + entity_onboarding_session = await async_client.simulations.entity_onboarding_sessions.submit( + "entity_onboarding_session_wid2ug11fsmvh3k9hymd", + ) + assert_matches_type(EntityOnboardingSession, entity_onboarding_session, path=["response"]) + + @parametrize + async def test_raw_response_submit(self, async_client: AsyncIncrease) -> None: + response = await async_client.simulations.entity_onboarding_sessions.with_raw_response.submit( + "entity_onboarding_session_wid2ug11fsmvh3k9hymd", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + entity_onboarding_session = await response.parse() + assert_matches_type(EntityOnboardingSession, entity_onboarding_session, path=["response"]) + + @parametrize + async def test_streaming_response_submit(self, async_client: AsyncIncrease) -> None: + async with async_client.simulations.entity_onboarding_sessions.with_streaming_response.submit( + "entity_onboarding_session_wid2ug11fsmvh3k9hymd", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + entity_onboarding_session = await response.parse() + assert_matches_type(EntityOnboardingSession, entity_onboarding_session, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_path_params_submit(self, async_client: AsyncIncrease) -> None: + with pytest.raises( + ValueError, match=r"Expected a non-empty value for `entity_onboarding_session_id` but received ''" + ): + await async_client.simulations.entity_onboarding_sessions.with_raw_response.submit( + "", + ) diff --git a/tests/api_resources/test_entity_onboarding_sessions.py b/tests/api_resources/test_entity_onboarding_sessions.py new file mode 100644 index 00000000..cd90a32e --- /dev/null +++ b/tests/api_resources/test_entity_onboarding_sessions.py @@ -0,0 +1,343 @@ +# 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 ( + EntityOnboardingSession, +) +from increase.pagination import SyncPage, AsyncPage + +base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") + + +class TestEntityOnboardingSessions: + parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) + + @parametrize + def test_method_create(self, client: Increase) -> None: + entity_onboarding_session = client.entity_onboarding_sessions.create( + program_id="program_i2v2os4mwza1oetokh9i", + redirect_url="https://example.com/onboarding/session", + ) + assert_matches_type(EntityOnboardingSession, entity_onboarding_session, path=["response"]) + + @parametrize + def test_method_create_with_all_params(self, client: Increase) -> None: + entity_onboarding_session = client.entity_onboarding_sessions.create( + program_id="program_i2v2os4mwza1oetokh9i", + redirect_url="https://example.com/onboarding/session", + entity_id="entity_id", + ) + assert_matches_type(EntityOnboardingSession, entity_onboarding_session, path=["response"]) + + @parametrize + def test_raw_response_create(self, client: Increase) -> None: + response = client.entity_onboarding_sessions.with_raw_response.create( + program_id="program_i2v2os4mwza1oetokh9i", + redirect_url="https://example.com/onboarding/session", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + entity_onboarding_session = response.parse() + assert_matches_type(EntityOnboardingSession, entity_onboarding_session, path=["response"]) + + @parametrize + def test_streaming_response_create(self, client: Increase) -> None: + with client.entity_onboarding_sessions.with_streaming_response.create( + program_id="program_i2v2os4mwza1oetokh9i", + redirect_url="https://example.com/onboarding/session", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + entity_onboarding_session = response.parse() + assert_matches_type(EntityOnboardingSession, entity_onboarding_session, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_method_retrieve(self, client: Increase) -> None: + entity_onboarding_session = client.entity_onboarding_sessions.retrieve( + "entity_onboarding_session_wid2ug11fsmvh3k9hymd", + ) + assert_matches_type(EntityOnboardingSession, entity_onboarding_session, path=["response"]) + + @parametrize + def test_raw_response_retrieve(self, client: Increase) -> None: + response = client.entity_onboarding_sessions.with_raw_response.retrieve( + "entity_onboarding_session_wid2ug11fsmvh3k9hymd", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + entity_onboarding_session = response.parse() + assert_matches_type(EntityOnboardingSession, entity_onboarding_session, path=["response"]) + + @parametrize + def test_streaming_response_retrieve(self, client: Increase) -> None: + with client.entity_onboarding_sessions.with_streaming_response.retrieve( + "entity_onboarding_session_wid2ug11fsmvh3k9hymd", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + entity_onboarding_session = response.parse() + assert_matches_type(EntityOnboardingSession, entity_onboarding_session, 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 `entity_onboarding_session_id` but received ''" + ): + client.entity_onboarding_sessions.with_raw_response.retrieve( + "", + ) + + @parametrize + def test_method_list(self, client: Increase) -> None: + entity_onboarding_session = client.entity_onboarding_sessions.list() + assert_matches_type(SyncPage[EntityOnboardingSession], entity_onboarding_session, path=["response"]) + + @parametrize + def test_method_list_with_all_params(self, client: Increase) -> None: + entity_onboarding_session = client.entity_onboarding_sessions.list( + cursor="cursor", + idempotency_key="x", + limit=1, + status={"in": ["active"]}, + ) + assert_matches_type(SyncPage[EntityOnboardingSession], entity_onboarding_session, path=["response"]) + + @parametrize + def test_raw_response_list(self, client: Increase) -> None: + response = client.entity_onboarding_sessions.with_raw_response.list() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + entity_onboarding_session = response.parse() + assert_matches_type(SyncPage[EntityOnboardingSession], entity_onboarding_session, path=["response"]) + + @parametrize + def test_streaming_response_list(self, client: Increase) -> None: + with client.entity_onboarding_sessions.with_streaming_response.list() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + entity_onboarding_session = response.parse() + assert_matches_type(SyncPage[EntityOnboardingSession], entity_onboarding_session, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_method_expire(self, client: Increase) -> None: + entity_onboarding_session = client.entity_onboarding_sessions.expire( + "entity_onboarding_session_wid2ug11fsmvh3k9hymd", + ) + assert_matches_type(EntityOnboardingSession, entity_onboarding_session, path=["response"]) + + @parametrize + def test_raw_response_expire(self, client: Increase) -> None: + response = client.entity_onboarding_sessions.with_raw_response.expire( + "entity_onboarding_session_wid2ug11fsmvh3k9hymd", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + entity_onboarding_session = response.parse() + assert_matches_type(EntityOnboardingSession, entity_onboarding_session, path=["response"]) + + @parametrize + def test_streaming_response_expire(self, client: Increase) -> None: + with client.entity_onboarding_sessions.with_streaming_response.expire( + "entity_onboarding_session_wid2ug11fsmvh3k9hymd", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + entity_onboarding_session = response.parse() + assert_matches_type(EntityOnboardingSession, entity_onboarding_session, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_path_params_expire(self, client: Increase) -> None: + with pytest.raises( + ValueError, match=r"Expected a non-empty value for `entity_onboarding_session_id` but received ''" + ): + client.entity_onboarding_sessions.with_raw_response.expire( + "", + ) + + +class TestAsyncEntityOnboardingSessions: + 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: + entity_onboarding_session = await async_client.entity_onboarding_sessions.create( + program_id="program_i2v2os4mwza1oetokh9i", + redirect_url="https://example.com/onboarding/session", + ) + assert_matches_type(EntityOnboardingSession, entity_onboarding_session, path=["response"]) + + @parametrize + async def test_method_create_with_all_params(self, async_client: AsyncIncrease) -> None: + entity_onboarding_session = await async_client.entity_onboarding_sessions.create( + program_id="program_i2v2os4mwza1oetokh9i", + redirect_url="https://example.com/onboarding/session", + entity_id="entity_id", + ) + assert_matches_type(EntityOnboardingSession, entity_onboarding_session, path=["response"]) + + @parametrize + async def test_raw_response_create(self, async_client: AsyncIncrease) -> None: + response = await async_client.entity_onboarding_sessions.with_raw_response.create( + program_id="program_i2v2os4mwza1oetokh9i", + redirect_url="https://example.com/onboarding/session", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + entity_onboarding_session = await response.parse() + assert_matches_type(EntityOnboardingSession, entity_onboarding_session, path=["response"]) + + @parametrize + async def test_streaming_response_create(self, async_client: AsyncIncrease) -> None: + async with async_client.entity_onboarding_sessions.with_streaming_response.create( + program_id="program_i2v2os4mwza1oetokh9i", + redirect_url="https://example.com/onboarding/session", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + entity_onboarding_session = await response.parse() + assert_matches_type(EntityOnboardingSession, entity_onboarding_session, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_method_retrieve(self, async_client: AsyncIncrease) -> None: + entity_onboarding_session = await async_client.entity_onboarding_sessions.retrieve( + "entity_onboarding_session_wid2ug11fsmvh3k9hymd", + ) + assert_matches_type(EntityOnboardingSession, entity_onboarding_session, path=["response"]) + + @parametrize + async def test_raw_response_retrieve(self, async_client: AsyncIncrease) -> None: + response = await async_client.entity_onboarding_sessions.with_raw_response.retrieve( + "entity_onboarding_session_wid2ug11fsmvh3k9hymd", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + entity_onboarding_session = await response.parse() + assert_matches_type(EntityOnboardingSession, entity_onboarding_session, path=["response"]) + + @parametrize + async def test_streaming_response_retrieve(self, async_client: AsyncIncrease) -> None: + async with async_client.entity_onboarding_sessions.with_streaming_response.retrieve( + "entity_onboarding_session_wid2ug11fsmvh3k9hymd", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + entity_onboarding_session = await response.parse() + assert_matches_type(EntityOnboardingSession, entity_onboarding_session, 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 `entity_onboarding_session_id` but received ''" + ): + await async_client.entity_onboarding_sessions.with_raw_response.retrieve( + "", + ) + + @parametrize + async def test_method_list(self, async_client: AsyncIncrease) -> None: + entity_onboarding_session = await async_client.entity_onboarding_sessions.list() + assert_matches_type(AsyncPage[EntityOnboardingSession], entity_onboarding_session, path=["response"]) + + @parametrize + async def test_method_list_with_all_params(self, async_client: AsyncIncrease) -> None: + entity_onboarding_session = await async_client.entity_onboarding_sessions.list( + cursor="cursor", + idempotency_key="x", + limit=1, + status={"in": ["active"]}, + ) + assert_matches_type(AsyncPage[EntityOnboardingSession], entity_onboarding_session, path=["response"]) + + @parametrize + async def test_raw_response_list(self, async_client: AsyncIncrease) -> None: + response = await async_client.entity_onboarding_sessions.with_raw_response.list() + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + entity_onboarding_session = await response.parse() + assert_matches_type(AsyncPage[EntityOnboardingSession], entity_onboarding_session, path=["response"]) + + @parametrize + async def test_streaming_response_list(self, async_client: AsyncIncrease) -> None: + async with async_client.entity_onboarding_sessions.with_streaming_response.list() as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + entity_onboarding_session = await response.parse() + assert_matches_type(AsyncPage[EntityOnboardingSession], entity_onboarding_session, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_method_expire(self, async_client: AsyncIncrease) -> None: + entity_onboarding_session = await async_client.entity_onboarding_sessions.expire( + "entity_onboarding_session_wid2ug11fsmvh3k9hymd", + ) + assert_matches_type(EntityOnboardingSession, entity_onboarding_session, path=["response"]) + + @parametrize + async def test_raw_response_expire(self, async_client: AsyncIncrease) -> None: + response = await async_client.entity_onboarding_sessions.with_raw_response.expire( + "entity_onboarding_session_wid2ug11fsmvh3k9hymd", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + entity_onboarding_session = await response.parse() + assert_matches_type(EntityOnboardingSession, entity_onboarding_session, path=["response"]) + + @parametrize + async def test_streaming_response_expire(self, async_client: AsyncIncrease) -> None: + async with async_client.entity_onboarding_sessions.with_streaming_response.expire( + "entity_onboarding_session_wid2ug11fsmvh3k9hymd", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + entity_onboarding_session = await response.parse() + assert_matches_type(EntityOnboardingSession, entity_onboarding_session, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_path_params_expire(self, async_client: AsyncIncrease) -> None: + with pytest.raises( + ValueError, match=r"Expected a non-empty value for `entity_onboarding_session_id` but received ''" + ): + await async_client.entity_onboarding_sessions.with_raw_response.expire( + "", + )