diff --git a/.release-please-manifest.json b/.release-please-manifest.json
index 905c8453a..3dbadeb74 100644
--- a/.release-please-manifest.json
+++ b/.release-please-manifest.json
@@ -1,3 +1,3 @@
{
- ".": "0.416.0"
+ ".": "0.417.0"
}
\ No newline at end of file
diff --git a/.stats.yml b/.stats.yml
index c34fe88d8..b1d32ecc6 100644
--- a/.stats.yml
+++ b/.stats.yml
@@ -1,4 +1,4 @@
-configured_endpoints: 230
-openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/increase%2Fincrease-01b0246dcddc851a762ec864d0a728fb63f4020fe94039d2403518b22f3af120.yml
-openapi_spec_hash: 773dfed2baf70342616421533b9b5a56
-config_hash: ff2eb5f192b4de36611b37b27961c2d8
+configured_endpoints: 227
+openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/increase%2Fincrease-63db8a5872b6a112abfc879f75a53bc6975994025752e86b27ab327884d94655.yml
+openapi_spec_hash: b7ffb71e0102fcd040a575bf917656e3
+config_hash: ca52ca9a2968f330339fd50c1a386e05
diff --git a/CHANGELOG.md b/CHANGELOG.md
index cb78e201c..baa6cc7fa 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,28 @@
# Changelog
+## 0.417.0 (2025-12-26)
+
+Full Changelog: [v0.416.0...v0.417.0](https://github.com/Increase/increase-python/compare/v0.416.0...v0.417.0)
+
+### Features
+
+* **api:** api update ([e2b0365](https://github.com/Increase/increase-python/commit/e2b0365db5b62be17329c0c9b468f5ba5e99b6f9))
+* **api:** api update ([d6a0d4f](https://github.com/Increase/increase-python/commit/d6a0d4f554b965fd1f4960243a1d6446e5d33e33))
+* **api:** api update ([e858da5](https://github.com/Increase/increase-python/commit/e858da5079a61f75022728757ac00508f1e74946))
+* **api:** api update ([2c6557c](https://github.com/Increase/increase-python/commit/2c6557c60b60ee0e2535f29c05e00333ca09435d))
+* **api:** api update ([8894aea](https://github.com/Increase/increase-python/commit/8894aea5a61f7b9b1551827e6ceae12a8c8d9bef))
+
+
+### Bug Fixes
+
+* use async_to_httpx_files in patch method ([d547dac](https://github.com/Increase/increase-python/commit/d547dac930116c8b431a3f265753352f3f8fa38a))
+
+
+### Chores
+
+* **internal:** add `--fix` argument to lint script ([e301f82](https://github.com/Increase/increase-python/commit/e301f82596a7bc2cece91e7defe42df9d1f749d3))
+* speedup initial import ([d9fe2b3](https://github.com/Increase/increase-python/commit/d9fe2b30e763a7cbfb225e53df81e4e6f06b926d))
+
## 0.416.0 (2025-12-16)
Full Changelog: [v0.415.0...v0.416.0](https://github.com/Increase/increase-python/compare/v0.415.0...v0.416.0)
diff --git a/README.md b/README.md
index 4edd8177b..cb9cc40ac 100644
--- a/README.md
+++ b/README.md
@@ -240,13 +240,13 @@ app = Flask(__name__)
# - The `secret` argument to `webhooks.unwrap`
client = Increase()
+
@app.route("/webhook", methods=["POST"])
def webhook():
request_body = request.get_data(as_text=True)
try:
-
- event = client.webhooks.unwrap(request_body, request.headers, secret='your webhook secret')
+ event = client.webhooks.unwrap(request_body, request.headers, secret="your webhook secret")
if event.type == "account.created":
print("Account created:", event.data)
@@ -284,6 +284,7 @@ app = Flask(__name__)
# - The `secret` argument to `webhooks.unwrap`
client = Increase()
+
@app.route("/webhook", methods=["POST"])
def webhook():
request_body = request.get_data(as_text=True)
diff --git a/api.md b/api.md
index ce4aecba3..f1b050fbc 100644
--- a/api.md
+++ b/api.md
@@ -557,20 +557,6 @@ Methods:
- client.file_links.create(\*\*params) -> FileLink
-# Documents
-
-Types:
-
-```python
-from increase.types import Document
-```
-
-Methods:
-
-- client.documents.create(\*\*params) -> Document
-- client.documents.retrieve(document_id) -> Document
-- client.documents.list(\*\*params) -> SyncPage[Document]
-
# Exports
Types:
@@ -1008,11 +994,11 @@ Methods:
- client.simulations.account_statements.create(\*\*params) -> AccountStatement
-## Documents
+## Exports
Methods:
-- client.simulations.documents.create(\*\*params) -> Document
+- client.simulations.exports.create(\*\*params) -> Export
## CardTokens
diff --git a/pyproject.toml b/pyproject.toml
index 841b286b3..a06a1d680 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,6 +1,6 @@
[project]
name = "increase"
-version = "0.416.0"
+version = "0.417.0"
description = "The official Python library for the increase API"
dynamic = ["readme"]
license = "Apache-2.0"
diff --git a/scripts/lint b/scripts/lint
index 76686137c..7dc201de4 100755
--- a/scripts/lint
+++ b/scripts/lint
@@ -4,8 +4,13 @@ set -e
cd "$(dirname "$0")/.."
-echo "==> Running lints"
-rye run lint
+if [ "$1" = "--fix" ]; then
+ echo "==> Running lints with --fix"
+ rye run fix:ruff
+else
+ echo "==> Running lints"
+ rye run lint
+fi
echo "==> Making sure it imports"
rye run python -c 'import increase'
diff --git a/src/increase/_base_client.py b/src/increase/_base_client.py
index 479c6ccc4..ac8ef78c1 100644
--- a/src/increase/_base_client.py
+++ b/src/increase/_base_client.py
@@ -1774,7 +1774,7 @@ async def patch(
options: RequestOptions = {},
) -> ResponseT:
opts = FinalRequestOptions.construct(
- method="patch", url=path, json_data=body, files=to_httpx_files(files), **options
+ method="patch", url=path, json_data=body, files=await async_to_httpx_files(files), **options
)
return await self.request(cast_to, opts)
diff --git a/src/increase/_client.py b/src/increase/_client.py
index 63e639fda..a4bc4519b 100644
--- a/src/increase/_client.py
+++ b/src/increase/_client.py
@@ -3,7 +3,7 @@
from __future__ import annotations
import os
-from typing import Any, Dict, Mapping, cast
+from typing import TYPE_CHECKING, Any, Dict, Mapping, cast
from typing_extensions import Self, Literal, override
import httpx
@@ -24,66 +24,8 @@
is_mapping,
get_async_library,
)
+from ._compat import cached_property
from ._version import __version__
-from .resources import (
- cards,
- files,
- events,
- groups,
- exports,
- accounts,
- entities,
- programs,
- webhooks,
- documents,
- lockboxes,
- file_links,
- card_tokens,
- oauth_tokens,
- transactions,
- ach_transfers,
- card_disputes,
- card_payments,
- check_deposits,
- physical_cards,
- wire_transfers,
- account_numbers,
- check_transfers,
- routing_numbers,
- card_validations,
- fednow_transfers,
- intrafi_balances,
- account_transfers,
- external_accounts,
- oauth_connections,
- account_statements,
- inbound_mail_items,
- intrafi_exclusions,
- oauth_applications,
- bookkeeping_entries,
- card_push_transfers,
- event_subscriptions,
- real_time_decisions,
- ach_prenotifications,
- bookkeeping_accounts,
- pending_transactions,
- declined_transactions,
- digital_card_profiles,
- digital_wallet_tokens,
- inbound_ach_transfers,
- bookkeeping_entry_sets,
- inbound_check_deposits,
- inbound_wire_transfers,
- physical_card_profiles,
- supplemental_documents,
- wire_drawdown_requests,
- inbound_fednow_transfers,
- card_purchase_supplements,
- intrafi_account_enrollments,
- real_time_payments_transfers,
- inbound_wire_drawdown_requests,
- inbound_real_time_payments_transfers,
-)
from ._streaming import Stream as Stream, AsyncStream as AsyncStream
from ._exceptions import IncreaseError, APIStatusError
from ._base_client import (
@@ -91,7 +33,457 @@
SyncAPIClient,
AsyncAPIClient,
)
-from .resources.simulations import simulations
+
+if TYPE_CHECKING:
+ from .resources.cards import (
+ CardsResource,
+ AsyncCardsResource,
+ CardsResourceWithRawResponse,
+ AsyncCardsResourceWithRawResponse,
+ CardsResourceWithStreamingResponse,
+ AsyncCardsResourceWithStreamingResponse,
+ )
+ from .resources.files import (
+ FilesResource,
+ AsyncFilesResource,
+ FilesResourceWithRawResponse,
+ AsyncFilesResourceWithRawResponse,
+ FilesResourceWithStreamingResponse,
+ AsyncFilesResourceWithStreamingResponse,
+ )
+ from .resources.events import (
+ EventsResource,
+ AsyncEventsResource,
+ EventsResourceWithRawResponse,
+ AsyncEventsResourceWithRawResponse,
+ EventsResourceWithStreamingResponse,
+ AsyncEventsResourceWithStreamingResponse,
+ )
+ from .resources.groups import (
+ GroupsResource,
+ AsyncGroupsResource,
+ GroupsResourceWithRawResponse,
+ AsyncGroupsResourceWithRawResponse,
+ GroupsResourceWithStreamingResponse,
+ AsyncGroupsResourceWithStreamingResponse,
+ )
+ from .resources.exports import (
+ ExportsResource,
+ AsyncExportsResource,
+ ExportsResourceWithRawResponse,
+ AsyncExportsResourceWithRawResponse,
+ ExportsResourceWithStreamingResponse,
+ AsyncExportsResourceWithStreamingResponse,
+ )
+ from .resources.accounts import (
+ AccountsResource,
+ AsyncAccountsResource,
+ AccountsResourceWithRawResponse,
+ AsyncAccountsResourceWithRawResponse,
+ AccountsResourceWithStreamingResponse,
+ AsyncAccountsResourceWithStreamingResponse,
+ )
+ from .resources.entities import (
+ EntitiesResource,
+ AsyncEntitiesResource,
+ EntitiesResourceWithRawResponse,
+ AsyncEntitiesResourceWithRawResponse,
+ EntitiesResourceWithStreamingResponse,
+ AsyncEntitiesResourceWithStreamingResponse,
+ )
+ from .resources.programs import (
+ ProgramsResource,
+ AsyncProgramsResource,
+ ProgramsResourceWithRawResponse,
+ AsyncProgramsResourceWithRawResponse,
+ ProgramsResourceWithStreamingResponse,
+ AsyncProgramsResourceWithStreamingResponse,
+ )
+ from .resources.webhooks import Webhooks, AsyncWebhooks
+ from .resources.lockboxes import (
+ LockboxesResource,
+ AsyncLockboxesResource,
+ LockboxesResourceWithRawResponse,
+ AsyncLockboxesResourceWithRawResponse,
+ LockboxesResourceWithStreamingResponse,
+ AsyncLockboxesResourceWithStreamingResponse,
+ )
+ from .resources.file_links import (
+ FileLinksResource,
+ AsyncFileLinksResource,
+ FileLinksResourceWithRawResponse,
+ AsyncFileLinksResourceWithRawResponse,
+ FileLinksResourceWithStreamingResponse,
+ AsyncFileLinksResourceWithStreamingResponse,
+ )
+ from .resources.card_tokens import (
+ CardTokensResource,
+ AsyncCardTokensResource,
+ CardTokensResourceWithRawResponse,
+ AsyncCardTokensResourceWithRawResponse,
+ CardTokensResourceWithStreamingResponse,
+ AsyncCardTokensResourceWithStreamingResponse,
+ )
+ from .resources.oauth_tokens import (
+ OAuthTokensResource,
+ AsyncOAuthTokensResource,
+ OAuthTokensResourceWithRawResponse,
+ AsyncOAuthTokensResourceWithRawResponse,
+ OAuthTokensResourceWithStreamingResponse,
+ AsyncOAuthTokensResourceWithStreamingResponse,
+ )
+ from .resources.transactions import (
+ TransactionsResource,
+ AsyncTransactionsResource,
+ TransactionsResourceWithRawResponse,
+ AsyncTransactionsResourceWithRawResponse,
+ TransactionsResourceWithStreamingResponse,
+ AsyncTransactionsResourceWithStreamingResponse,
+ )
+ from .resources.ach_transfers import (
+ ACHTransfersResource,
+ AsyncACHTransfersResource,
+ ACHTransfersResourceWithRawResponse,
+ AsyncACHTransfersResourceWithRawResponse,
+ ACHTransfersResourceWithStreamingResponse,
+ AsyncACHTransfersResourceWithStreamingResponse,
+ )
+ from .resources.card_disputes import (
+ CardDisputesResource,
+ AsyncCardDisputesResource,
+ CardDisputesResourceWithRawResponse,
+ AsyncCardDisputesResourceWithRawResponse,
+ CardDisputesResourceWithStreamingResponse,
+ AsyncCardDisputesResourceWithStreamingResponse,
+ )
+ from .resources.card_payments import (
+ CardPaymentsResource,
+ AsyncCardPaymentsResource,
+ CardPaymentsResourceWithRawResponse,
+ AsyncCardPaymentsResourceWithRawResponse,
+ CardPaymentsResourceWithStreamingResponse,
+ AsyncCardPaymentsResourceWithStreamingResponse,
+ )
+ from .resources.check_deposits import (
+ CheckDepositsResource,
+ AsyncCheckDepositsResource,
+ CheckDepositsResourceWithRawResponse,
+ AsyncCheckDepositsResourceWithRawResponse,
+ CheckDepositsResourceWithStreamingResponse,
+ AsyncCheckDepositsResourceWithStreamingResponse,
+ )
+ from .resources.physical_cards import (
+ PhysicalCardsResource,
+ AsyncPhysicalCardsResource,
+ PhysicalCardsResourceWithRawResponse,
+ AsyncPhysicalCardsResourceWithRawResponse,
+ PhysicalCardsResourceWithStreamingResponse,
+ AsyncPhysicalCardsResourceWithStreamingResponse,
+ )
+ from .resources.wire_transfers import (
+ WireTransfersResource,
+ AsyncWireTransfersResource,
+ WireTransfersResourceWithRawResponse,
+ AsyncWireTransfersResourceWithRawResponse,
+ WireTransfersResourceWithStreamingResponse,
+ AsyncWireTransfersResourceWithStreamingResponse,
+ )
+ from .resources.account_numbers import (
+ AccountNumbersResource,
+ AsyncAccountNumbersResource,
+ AccountNumbersResourceWithRawResponse,
+ AsyncAccountNumbersResourceWithRawResponse,
+ AccountNumbersResourceWithStreamingResponse,
+ AsyncAccountNumbersResourceWithStreamingResponse,
+ )
+ from .resources.check_transfers import (
+ CheckTransfersResource,
+ AsyncCheckTransfersResource,
+ CheckTransfersResourceWithRawResponse,
+ AsyncCheckTransfersResourceWithRawResponse,
+ CheckTransfersResourceWithStreamingResponse,
+ AsyncCheckTransfersResourceWithStreamingResponse,
+ )
+ from .resources.routing_numbers import (
+ RoutingNumbersResource,
+ AsyncRoutingNumbersResource,
+ RoutingNumbersResourceWithRawResponse,
+ AsyncRoutingNumbersResourceWithRawResponse,
+ RoutingNumbersResourceWithStreamingResponse,
+ AsyncRoutingNumbersResourceWithStreamingResponse,
+ )
+ from .resources.card_validations import (
+ CardValidationsResource,
+ AsyncCardValidationsResource,
+ CardValidationsResourceWithRawResponse,
+ AsyncCardValidationsResourceWithRawResponse,
+ CardValidationsResourceWithStreamingResponse,
+ AsyncCardValidationsResourceWithStreamingResponse,
+ )
+ from .resources.fednow_transfers import (
+ FednowTransfersResource,
+ AsyncFednowTransfersResource,
+ FednowTransfersResourceWithRawResponse,
+ AsyncFednowTransfersResourceWithRawResponse,
+ FednowTransfersResourceWithStreamingResponse,
+ AsyncFednowTransfersResourceWithStreamingResponse,
+ )
+ from .resources.intrafi_balances import (
+ IntrafiBalancesResource,
+ AsyncIntrafiBalancesResource,
+ IntrafiBalancesResourceWithRawResponse,
+ AsyncIntrafiBalancesResourceWithRawResponse,
+ IntrafiBalancesResourceWithStreamingResponse,
+ AsyncIntrafiBalancesResourceWithStreamingResponse,
+ )
+ from .resources.account_transfers import (
+ AccountTransfersResource,
+ AsyncAccountTransfersResource,
+ AccountTransfersResourceWithRawResponse,
+ AsyncAccountTransfersResourceWithRawResponse,
+ AccountTransfersResourceWithStreamingResponse,
+ AsyncAccountTransfersResourceWithStreamingResponse,
+ )
+ from .resources.external_accounts import (
+ ExternalAccountsResource,
+ AsyncExternalAccountsResource,
+ ExternalAccountsResourceWithRawResponse,
+ AsyncExternalAccountsResourceWithRawResponse,
+ ExternalAccountsResourceWithStreamingResponse,
+ AsyncExternalAccountsResourceWithStreamingResponse,
+ )
+ from .resources.oauth_connections import (
+ OAuthConnectionsResource,
+ AsyncOAuthConnectionsResource,
+ OAuthConnectionsResourceWithRawResponse,
+ AsyncOAuthConnectionsResourceWithRawResponse,
+ OAuthConnectionsResourceWithStreamingResponse,
+ AsyncOAuthConnectionsResourceWithStreamingResponse,
+ )
+ from .resources.account_statements import (
+ AccountStatementsResource,
+ AsyncAccountStatementsResource,
+ AccountStatementsResourceWithRawResponse,
+ AsyncAccountStatementsResourceWithRawResponse,
+ AccountStatementsResourceWithStreamingResponse,
+ AsyncAccountStatementsResourceWithStreamingResponse,
+ )
+ from .resources.inbound_mail_items import (
+ InboundMailItemsResource,
+ AsyncInboundMailItemsResource,
+ InboundMailItemsResourceWithRawResponse,
+ AsyncInboundMailItemsResourceWithRawResponse,
+ InboundMailItemsResourceWithStreamingResponse,
+ AsyncInboundMailItemsResourceWithStreamingResponse,
+ )
+ from .resources.intrafi_exclusions import (
+ IntrafiExclusionsResource,
+ AsyncIntrafiExclusionsResource,
+ IntrafiExclusionsResourceWithRawResponse,
+ AsyncIntrafiExclusionsResourceWithRawResponse,
+ IntrafiExclusionsResourceWithStreamingResponse,
+ AsyncIntrafiExclusionsResourceWithStreamingResponse,
+ )
+ from .resources.oauth_applications import (
+ OAuthApplicationsResource,
+ AsyncOAuthApplicationsResource,
+ OAuthApplicationsResourceWithRawResponse,
+ AsyncOAuthApplicationsResourceWithRawResponse,
+ OAuthApplicationsResourceWithStreamingResponse,
+ AsyncOAuthApplicationsResourceWithStreamingResponse,
+ )
+ from .resources.bookkeeping_entries import (
+ BookkeepingEntriesResource,
+ AsyncBookkeepingEntriesResource,
+ BookkeepingEntriesResourceWithRawResponse,
+ AsyncBookkeepingEntriesResourceWithRawResponse,
+ BookkeepingEntriesResourceWithStreamingResponse,
+ AsyncBookkeepingEntriesResourceWithStreamingResponse,
+ )
+ from .resources.card_push_transfers import (
+ CardPushTransfersResource,
+ AsyncCardPushTransfersResource,
+ CardPushTransfersResourceWithRawResponse,
+ AsyncCardPushTransfersResourceWithRawResponse,
+ CardPushTransfersResourceWithStreamingResponse,
+ AsyncCardPushTransfersResourceWithStreamingResponse,
+ )
+ from .resources.event_subscriptions import (
+ EventSubscriptionsResource,
+ AsyncEventSubscriptionsResource,
+ EventSubscriptionsResourceWithRawResponse,
+ AsyncEventSubscriptionsResourceWithRawResponse,
+ EventSubscriptionsResourceWithStreamingResponse,
+ AsyncEventSubscriptionsResourceWithStreamingResponse,
+ )
+ from .resources.real_time_decisions import (
+ RealTimeDecisionsResource,
+ AsyncRealTimeDecisionsResource,
+ RealTimeDecisionsResourceWithRawResponse,
+ AsyncRealTimeDecisionsResourceWithRawResponse,
+ RealTimeDecisionsResourceWithStreamingResponse,
+ AsyncRealTimeDecisionsResourceWithStreamingResponse,
+ )
+ from .resources.ach_prenotifications import (
+ ACHPrenotificationsResource,
+ AsyncACHPrenotificationsResource,
+ ACHPrenotificationsResourceWithRawResponse,
+ AsyncACHPrenotificationsResourceWithRawResponse,
+ ACHPrenotificationsResourceWithStreamingResponse,
+ AsyncACHPrenotificationsResourceWithStreamingResponse,
+ )
+ from .resources.bookkeeping_accounts import (
+ BookkeepingAccountsResource,
+ AsyncBookkeepingAccountsResource,
+ BookkeepingAccountsResourceWithRawResponse,
+ AsyncBookkeepingAccountsResourceWithRawResponse,
+ BookkeepingAccountsResourceWithStreamingResponse,
+ AsyncBookkeepingAccountsResourceWithStreamingResponse,
+ )
+ from .resources.pending_transactions import (
+ PendingTransactionsResource,
+ AsyncPendingTransactionsResource,
+ PendingTransactionsResourceWithRawResponse,
+ AsyncPendingTransactionsResourceWithRawResponse,
+ PendingTransactionsResourceWithStreamingResponse,
+ AsyncPendingTransactionsResourceWithStreamingResponse,
+ )
+ from .resources.declined_transactions import (
+ DeclinedTransactionsResource,
+ AsyncDeclinedTransactionsResource,
+ DeclinedTransactionsResourceWithRawResponse,
+ AsyncDeclinedTransactionsResourceWithRawResponse,
+ DeclinedTransactionsResourceWithStreamingResponse,
+ AsyncDeclinedTransactionsResourceWithStreamingResponse,
+ )
+ from .resources.digital_card_profiles import (
+ DigitalCardProfilesResource,
+ AsyncDigitalCardProfilesResource,
+ DigitalCardProfilesResourceWithRawResponse,
+ AsyncDigitalCardProfilesResourceWithRawResponse,
+ DigitalCardProfilesResourceWithStreamingResponse,
+ AsyncDigitalCardProfilesResourceWithStreamingResponse,
+ )
+ from .resources.digital_wallet_tokens import (
+ DigitalWalletTokensResource,
+ AsyncDigitalWalletTokensResource,
+ DigitalWalletTokensResourceWithRawResponse,
+ AsyncDigitalWalletTokensResourceWithRawResponse,
+ DigitalWalletTokensResourceWithStreamingResponse,
+ AsyncDigitalWalletTokensResourceWithStreamingResponse,
+ )
+ from .resources.inbound_ach_transfers import (
+ InboundACHTransfersResource,
+ AsyncInboundACHTransfersResource,
+ InboundACHTransfersResourceWithRawResponse,
+ AsyncInboundACHTransfersResourceWithRawResponse,
+ InboundACHTransfersResourceWithStreamingResponse,
+ AsyncInboundACHTransfersResourceWithStreamingResponse,
+ )
+ from .resources.bookkeeping_entry_sets import (
+ BookkeepingEntrySetsResource,
+ AsyncBookkeepingEntrySetsResource,
+ BookkeepingEntrySetsResourceWithRawResponse,
+ AsyncBookkeepingEntrySetsResourceWithRawResponse,
+ BookkeepingEntrySetsResourceWithStreamingResponse,
+ AsyncBookkeepingEntrySetsResourceWithStreamingResponse,
+ )
+ from .resources.inbound_check_deposits import (
+ InboundCheckDepositsResource,
+ AsyncInboundCheckDepositsResource,
+ InboundCheckDepositsResourceWithRawResponse,
+ AsyncInboundCheckDepositsResourceWithRawResponse,
+ InboundCheckDepositsResourceWithStreamingResponse,
+ AsyncInboundCheckDepositsResourceWithStreamingResponse,
+ )
+ from .resources.inbound_wire_transfers import (
+ InboundWireTransfersResource,
+ AsyncInboundWireTransfersResource,
+ InboundWireTransfersResourceWithRawResponse,
+ AsyncInboundWireTransfersResourceWithRawResponse,
+ InboundWireTransfersResourceWithStreamingResponse,
+ AsyncInboundWireTransfersResourceWithStreamingResponse,
+ )
+ from .resources.physical_card_profiles import (
+ PhysicalCardProfilesResource,
+ AsyncPhysicalCardProfilesResource,
+ PhysicalCardProfilesResourceWithRawResponse,
+ AsyncPhysicalCardProfilesResourceWithRawResponse,
+ PhysicalCardProfilesResourceWithStreamingResponse,
+ AsyncPhysicalCardProfilesResourceWithStreamingResponse,
+ )
+ from .resources.supplemental_documents import (
+ SupplementalDocumentsResource,
+ AsyncSupplementalDocumentsResource,
+ SupplementalDocumentsResourceWithRawResponse,
+ AsyncSupplementalDocumentsResourceWithRawResponse,
+ SupplementalDocumentsResourceWithStreamingResponse,
+ AsyncSupplementalDocumentsResourceWithStreamingResponse,
+ )
+ from .resources.wire_drawdown_requests import (
+ WireDrawdownRequestsResource,
+ AsyncWireDrawdownRequestsResource,
+ WireDrawdownRequestsResourceWithRawResponse,
+ AsyncWireDrawdownRequestsResourceWithRawResponse,
+ WireDrawdownRequestsResourceWithStreamingResponse,
+ AsyncWireDrawdownRequestsResourceWithStreamingResponse,
+ )
+ from .resources.simulations.simulations import (
+ SimulationsResource,
+ AsyncSimulationsResource,
+ SimulationsResourceWithRawResponse,
+ AsyncSimulationsResourceWithRawResponse,
+ SimulationsResourceWithStreamingResponse,
+ AsyncSimulationsResourceWithStreamingResponse,
+ )
+ from .resources.inbound_fednow_transfers import (
+ InboundFednowTransfersResource,
+ AsyncInboundFednowTransfersResource,
+ InboundFednowTransfersResourceWithRawResponse,
+ AsyncInboundFednowTransfersResourceWithRawResponse,
+ InboundFednowTransfersResourceWithStreamingResponse,
+ AsyncInboundFednowTransfersResourceWithStreamingResponse,
+ )
+ from .resources.card_purchase_supplements import (
+ CardPurchaseSupplementsResource,
+ AsyncCardPurchaseSupplementsResource,
+ CardPurchaseSupplementsResourceWithRawResponse,
+ AsyncCardPurchaseSupplementsResourceWithRawResponse,
+ CardPurchaseSupplementsResourceWithStreamingResponse,
+ AsyncCardPurchaseSupplementsResourceWithStreamingResponse,
+ )
+ from .resources.intrafi_account_enrollments import (
+ IntrafiAccountEnrollmentsResource,
+ AsyncIntrafiAccountEnrollmentsResource,
+ IntrafiAccountEnrollmentsResourceWithRawResponse,
+ AsyncIntrafiAccountEnrollmentsResourceWithRawResponse,
+ IntrafiAccountEnrollmentsResourceWithStreamingResponse,
+ AsyncIntrafiAccountEnrollmentsResourceWithStreamingResponse,
+ )
+ from .resources.real_time_payments_transfers import (
+ RealTimePaymentsTransfersResource,
+ AsyncRealTimePaymentsTransfersResource,
+ RealTimePaymentsTransfersResourceWithRawResponse,
+ AsyncRealTimePaymentsTransfersResourceWithRawResponse,
+ RealTimePaymentsTransfersResourceWithStreamingResponse,
+ AsyncRealTimePaymentsTransfersResourceWithStreamingResponse,
+ )
+ from .resources.inbound_wire_drawdown_requests import (
+ InboundWireDrawdownRequestsResource,
+ AsyncInboundWireDrawdownRequestsResource,
+ InboundWireDrawdownRequestsResourceWithRawResponse,
+ AsyncInboundWireDrawdownRequestsResourceWithRawResponse,
+ InboundWireDrawdownRequestsResourceWithStreamingResponse,
+ AsyncInboundWireDrawdownRequestsResourceWithStreamingResponse,
+ )
+ from .resources.inbound_real_time_payments_transfers import (
+ InboundRealTimePaymentsTransfersResource,
+ AsyncInboundRealTimePaymentsTransfersResource,
+ InboundRealTimePaymentsTransfersResourceWithRawResponse,
+ AsyncInboundRealTimePaymentsTransfersResourceWithRawResponse,
+ InboundRealTimePaymentsTransfersResourceWithStreamingResponse,
+ AsyncInboundRealTimePaymentsTransfersResourceWithStreamingResponse,
+ )
__all__ = [
"ENVIRONMENTS",
@@ -112,67 +504,6 @@
class Increase(SyncAPIClient):
- accounts: accounts.AccountsResource
- account_numbers: account_numbers.AccountNumbersResource
- account_transfers: account_transfers.AccountTransfersResource
- cards: cards.CardsResource
- card_payments: card_payments.CardPaymentsResource
- card_purchase_supplements: card_purchase_supplements.CardPurchaseSupplementsResource
- card_disputes: card_disputes.CardDisputesResource
- physical_cards: physical_cards.PhysicalCardsResource
- digital_card_profiles: digital_card_profiles.DigitalCardProfilesResource
- physical_card_profiles: physical_card_profiles.PhysicalCardProfilesResource
- digital_wallet_tokens: digital_wallet_tokens.DigitalWalletTokensResource
- transactions: transactions.TransactionsResource
- pending_transactions: pending_transactions.PendingTransactionsResource
- declined_transactions: declined_transactions.DeclinedTransactionsResource
- ach_transfers: ach_transfers.ACHTransfersResource
- ach_prenotifications: ach_prenotifications.ACHPrenotificationsResource
- inbound_ach_transfers: inbound_ach_transfers.InboundACHTransfersResource
- wire_transfers: wire_transfers.WireTransfersResource
- inbound_wire_transfers: inbound_wire_transfers.InboundWireTransfersResource
- wire_drawdown_requests: wire_drawdown_requests.WireDrawdownRequestsResource
- inbound_wire_drawdown_requests: inbound_wire_drawdown_requests.InboundWireDrawdownRequestsResource
- check_transfers: check_transfers.CheckTransfersResource
- inbound_check_deposits: inbound_check_deposits.InboundCheckDepositsResource
- real_time_payments_transfers: real_time_payments_transfers.RealTimePaymentsTransfersResource
- inbound_real_time_payments_transfers: inbound_real_time_payments_transfers.InboundRealTimePaymentsTransfersResource
- fednow_transfers: fednow_transfers.FednowTransfersResource
- inbound_fednow_transfers: inbound_fednow_transfers.InboundFednowTransfersResource
- check_deposits: check_deposits.CheckDepositsResource
- lockboxes: lockboxes.LockboxesResource
- inbound_mail_items: inbound_mail_items.InboundMailItemsResource
- routing_numbers: routing_numbers.RoutingNumbersResource
- external_accounts: external_accounts.ExternalAccountsResource
- entities: entities.EntitiesResource
- supplemental_documents: supplemental_documents.SupplementalDocumentsResource
- programs: programs.ProgramsResource
- account_statements: account_statements.AccountStatementsResource
- files: files.FilesResource
- file_links: file_links.FileLinksResource
- documents: documents.DocumentsResource
- exports: exports.ExportsResource
- events: events.EventsResource
- event_subscriptions: event_subscriptions.EventSubscriptionsResource
- real_time_decisions: real_time_decisions.RealTimeDecisionsResource
- bookkeeping_accounts: bookkeeping_accounts.BookkeepingAccountsResource
- bookkeeping_entry_sets: bookkeeping_entry_sets.BookkeepingEntrySetsResource
- bookkeeping_entries: bookkeeping_entries.BookkeepingEntriesResource
- groups: groups.GroupsResource
- oauth_applications: oauth_applications.OAuthApplicationsResource
- oauth_connections: oauth_connections.OAuthConnectionsResource
- oauth_tokens: oauth_tokens.OAuthTokensResource
- intrafi_account_enrollments: intrafi_account_enrollments.IntrafiAccountEnrollmentsResource
- intrafi_balances: intrafi_balances.IntrafiBalancesResource
- intrafi_exclusions: intrafi_exclusions.IntrafiExclusionsResource
- card_tokens: card_tokens.CardTokensResource
- card_push_transfers: card_push_transfers.CardPushTransfersResource
- card_validations: card_validations.CardValidationsResource
- simulations: simulations.SimulationsResource
- webhooks: webhooks.Webhooks
- with_raw_response: IncreaseWithRawResponse
- with_streaming_response: IncreaseWithStreamedResponse
-
# client options
api_key: str
webhook_secret: str | None
@@ -261,68 +592,355 @@ def __init__(
self._idempotency_header = "Idempotency-Key"
- self.accounts = accounts.AccountsResource(self)
- self.account_numbers = account_numbers.AccountNumbersResource(self)
- self.account_transfers = account_transfers.AccountTransfersResource(self)
- self.cards = cards.CardsResource(self)
- self.card_payments = card_payments.CardPaymentsResource(self)
- self.card_purchase_supplements = card_purchase_supplements.CardPurchaseSupplementsResource(self)
- self.card_disputes = card_disputes.CardDisputesResource(self)
- self.physical_cards = physical_cards.PhysicalCardsResource(self)
- self.digital_card_profiles = digital_card_profiles.DigitalCardProfilesResource(self)
- self.physical_card_profiles = physical_card_profiles.PhysicalCardProfilesResource(self)
- self.digital_wallet_tokens = digital_wallet_tokens.DigitalWalletTokensResource(self)
- self.transactions = transactions.TransactionsResource(self)
- self.pending_transactions = pending_transactions.PendingTransactionsResource(self)
- self.declined_transactions = declined_transactions.DeclinedTransactionsResource(self)
- self.ach_transfers = ach_transfers.ACHTransfersResource(self)
- self.ach_prenotifications = ach_prenotifications.ACHPrenotificationsResource(self)
- self.inbound_ach_transfers = inbound_ach_transfers.InboundACHTransfersResource(self)
- self.wire_transfers = wire_transfers.WireTransfersResource(self)
- self.inbound_wire_transfers = inbound_wire_transfers.InboundWireTransfersResource(self)
- self.wire_drawdown_requests = wire_drawdown_requests.WireDrawdownRequestsResource(self)
- self.inbound_wire_drawdown_requests = inbound_wire_drawdown_requests.InboundWireDrawdownRequestsResource(self)
- self.check_transfers = check_transfers.CheckTransfersResource(self)
- self.inbound_check_deposits = inbound_check_deposits.InboundCheckDepositsResource(self)
- self.real_time_payments_transfers = real_time_payments_transfers.RealTimePaymentsTransfersResource(self)
- self.inbound_real_time_payments_transfers = (
- inbound_real_time_payments_transfers.InboundRealTimePaymentsTransfersResource(self)
- )
- self.fednow_transfers = fednow_transfers.FednowTransfersResource(self)
- self.inbound_fednow_transfers = inbound_fednow_transfers.InboundFednowTransfersResource(self)
- self.check_deposits = check_deposits.CheckDepositsResource(self)
- self.lockboxes = lockboxes.LockboxesResource(self)
- self.inbound_mail_items = inbound_mail_items.InboundMailItemsResource(self)
- self.routing_numbers = routing_numbers.RoutingNumbersResource(self)
- self.external_accounts = external_accounts.ExternalAccountsResource(self)
- self.entities = entities.EntitiesResource(self)
- self.supplemental_documents = supplemental_documents.SupplementalDocumentsResource(self)
- self.programs = programs.ProgramsResource(self)
- self.account_statements = account_statements.AccountStatementsResource(self)
- self.files = files.FilesResource(self)
- self.file_links = file_links.FileLinksResource(self)
- self.documents = documents.DocumentsResource(self)
- self.exports = exports.ExportsResource(self)
- self.events = events.EventsResource(self)
- self.event_subscriptions = event_subscriptions.EventSubscriptionsResource(self)
- self.real_time_decisions = real_time_decisions.RealTimeDecisionsResource(self)
- self.bookkeeping_accounts = bookkeeping_accounts.BookkeepingAccountsResource(self)
- self.bookkeeping_entry_sets = bookkeeping_entry_sets.BookkeepingEntrySetsResource(self)
- self.bookkeeping_entries = bookkeeping_entries.BookkeepingEntriesResource(self)
- self.groups = groups.GroupsResource(self)
- self.oauth_applications = oauth_applications.OAuthApplicationsResource(self)
- self.oauth_connections = oauth_connections.OAuthConnectionsResource(self)
- self.oauth_tokens = oauth_tokens.OAuthTokensResource(self)
- self.intrafi_account_enrollments = intrafi_account_enrollments.IntrafiAccountEnrollmentsResource(self)
- self.intrafi_balances = intrafi_balances.IntrafiBalancesResource(self)
- self.intrafi_exclusions = intrafi_exclusions.IntrafiExclusionsResource(self)
- self.card_tokens = card_tokens.CardTokensResource(self)
- self.card_push_transfers = card_push_transfers.CardPushTransfersResource(self)
- self.card_validations = card_validations.CardValidationsResource(self)
- self.simulations = simulations.SimulationsResource(self)
- self.webhooks = webhooks.Webhooks(self)
- self.with_raw_response = IncreaseWithRawResponse(self)
- self.with_streaming_response = IncreaseWithStreamedResponse(self)
+ @cached_property
+ def accounts(self) -> AccountsResource:
+ from .resources.accounts import AccountsResource
+
+ return AccountsResource(self)
+
+ @cached_property
+ def account_numbers(self) -> AccountNumbersResource:
+ from .resources.account_numbers import AccountNumbersResource
+
+ return AccountNumbersResource(self)
+
+ @cached_property
+ def account_transfers(self) -> AccountTransfersResource:
+ from .resources.account_transfers import AccountTransfersResource
+
+ return AccountTransfersResource(self)
+
+ @cached_property
+ def cards(self) -> CardsResource:
+ from .resources.cards import CardsResource
+
+ return CardsResource(self)
+
+ @cached_property
+ def card_payments(self) -> CardPaymentsResource:
+ from .resources.card_payments import CardPaymentsResource
+
+ return CardPaymentsResource(self)
+
+ @cached_property
+ def card_purchase_supplements(self) -> CardPurchaseSupplementsResource:
+ from .resources.card_purchase_supplements import CardPurchaseSupplementsResource
+
+ return CardPurchaseSupplementsResource(self)
+
+ @cached_property
+ def card_disputes(self) -> CardDisputesResource:
+ from .resources.card_disputes import CardDisputesResource
+
+ return CardDisputesResource(self)
+
+ @cached_property
+ def physical_cards(self) -> PhysicalCardsResource:
+ from .resources.physical_cards import PhysicalCardsResource
+
+ return PhysicalCardsResource(self)
+
+ @cached_property
+ def digital_card_profiles(self) -> DigitalCardProfilesResource:
+ from .resources.digital_card_profiles import DigitalCardProfilesResource
+
+ return DigitalCardProfilesResource(self)
+
+ @cached_property
+ def physical_card_profiles(self) -> PhysicalCardProfilesResource:
+ from .resources.physical_card_profiles import PhysicalCardProfilesResource
+
+ return PhysicalCardProfilesResource(self)
+
+ @cached_property
+ def digital_wallet_tokens(self) -> DigitalWalletTokensResource:
+ from .resources.digital_wallet_tokens import DigitalWalletTokensResource
+
+ return DigitalWalletTokensResource(self)
+
+ @cached_property
+ def transactions(self) -> TransactionsResource:
+ from .resources.transactions import TransactionsResource
+
+ return TransactionsResource(self)
+
+ @cached_property
+ def pending_transactions(self) -> PendingTransactionsResource:
+ from .resources.pending_transactions import PendingTransactionsResource
+
+ return PendingTransactionsResource(self)
+
+ @cached_property
+ def declined_transactions(self) -> DeclinedTransactionsResource:
+ from .resources.declined_transactions import DeclinedTransactionsResource
+
+ return DeclinedTransactionsResource(self)
+
+ @cached_property
+ def ach_transfers(self) -> ACHTransfersResource:
+ from .resources.ach_transfers import ACHTransfersResource
+
+ return ACHTransfersResource(self)
+
+ @cached_property
+ def ach_prenotifications(self) -> ACHPrenotificationsResource:
+ from .resources.ach_prenotifications import ACHPrenotificationsResource
+
+ return ACHPrenotificationsResource(self)
+
+ @cached_property
+ def inbound_ach_transfers(self) -> InboundACHTransfersResource:
+ from .resources.inbound_ach_transfers import InboundACHTransfersResource
+
+ return InboundACHTransfersResource(self)
+
+ @cached_property
+ def wire_transfers(self) -> WireTransfersResource:
+ from .resources.wire_transfers import WireTransfersResource
+
+ return WireTransfersResource(self)
+
+ @cached_property
+ def inbound_wire_transfers(self) -> InboundWireTransfersResource:
+ from .resources.inbound_wire_transfers import InboundWireTransfersResource
+
+ return InboundWireTransfersResource(self)
+
+ @cached_property
+ def wire_drawdown_requests(self) -> WireDrawdownRequestsResource:
+ from .resources.wire_drawdown_requests import WireDrawdownRequestsResource
+
+ return WireDrawdownRequestsResource(self)
+
+ @cached_property
+ def inbound_wire_drawdown_requests(self) -> InboundWireDrawdownRequestsResource:
+ from .resources.inbound_wire_drawdown_requests import InboundWireDrawdownRequestsResource
+
+ return InboundWireDrawdownRequestsResource(self)
+
+ @cached_property
+ def check_transfers(self) -> CheckTransfersResource:
+ from .resources.check_transfers import CheckTransfersResource
+
+ return CheckTransfersResource(self)
+
+ @cached_property
+ def inbound_check_deposits(self) -> InboundCheckDepositsResource:
+ from .resources.inbound_check_deposits import InboundCheckDepositsResource
+
+ return InboundCheckDepositsResource(self)
+
+ @cached_property
+ def real_time_payments_transfers(self) -> RealTimePaymentsTransfersResource:
+ from .resources.real_time_payments_transfers import RealTimePaymentsTransfersResource
+
+ return RealTimePaymentsTransfersResource(self)
+
+ @cached_property
+ def inbound_real_time_payments_transfers(self) -> InboundRealTimePaymentsTransfersResource:
+ from .resources.inbound_real_time_payments_transfers import InboundRealTimePaymentsTransfersResource
+
+ return InboundRealTimePaymentsTransfersResource(self)
+
+ @cached_property
+ def fednow_transfers(self) -> FednowTransfersResource:
+ from .resources.fednow_transfers import FednowTransfersResource
+
+ return FednowTransfersResource(self)
+
+ @cached_property
+ def inbound_fednow_transfers(self) -> InboundFednowTransfersResource:
+ from .resources.inbound_fednow_transfers import InboundFednowTransfersResource
+
+ return InboundFednowTransfersResource(self)
+
+ @cached_property
+ def check_deposits(self) -> CheckDepositsResource:
+ from .resources.check_deposits import CheckDepositsResource
+
+ return CheckDepositsResource(self)
+
+ @cached_property
+ def lockboxes(self) -> LockboxesResource:
+ from .resources.lockboxes import LockboxesResource
+
+ return LockboxesResource(self)
+
+ @cached_property
+ def inbound_mail_items(self) -> InboundMailItemsResource:
+ from .resources.inbound_mail_items import InboundMailItemsResource
+
+ return InboundMailItemsResource(self)
+
+ @cached_property
+ def routing_numbers(self) -> RoutingNumbersResource:
+ from .resources.routing_numbers import RoutingNumbersResource
+
+ return RoutingNumbersResource(self)
+
+ @cached_property
+ def external_accounts(self) -> ExternalAccountsResource:
+ from .resources.external_accounts import ExternalAccountsResource
+
+ return ExternalAccountsResource(self)
+
+ @cached_property
+ def entities(self) -> EntitiesResource:
+ from .resources.entities import EntitiesResource
+
+ return EntitiesResource(self)
+
+ @cached_property
+ def supplemental_documents(self) -> SupplementalDocumentsResource:
+ from .resources.supplemental_documents import SupplementalDocumentsResource
+
+ return SupplementalDocumentsResource(self)
+
+ @cached_property
+ def programs(self) -> ProgramsResource:
+ from .resources.programs import ProgramsResource
+
+ return ProgramsResource(self)
+
+ @cached_property
+ def account_statements(self) -> AccountStatementsResource:
+ from .resources.account_statements import AccountStatementsResource
+
+ return AccountStatementsResource(self)
+
+ @cached_property
+ def files(self) -> FilesResource:
+ from .resources.files import FilesResource
+
+ return FilesResource(self)
+
+ @cached_property
+ def file_links(self) -> FileLinksResource:
+ from .resources.file_links import FileLinksResource
+
+ return FileLinksResource(self)
+
+ @cached_property
+ def exports(self) -> ExportsResource:
+ from .resources.exports import ExportsResource
+
+ return ExportsResource(self)
+
+ @cached_property
+ def events(self) -> EventsResource:
+ from .resources.events import EventsResource
+
+ return EventsResource(self)
+
+ @cached_property
+ def event_subscriptions(self) -> EventSubscriptionsResource:
+ from .resources.event_subscriptions import EventSubscriptionsResource
+
+ return EventSubscriptionsResource(self)
+
+ @cached_property
+ def real_time_decisions(self) -> RealTimeDecisionsResource:
+ from .resources.real_time_decisions import RealTimeDecisionsResource
+
+ return RealTimeDecisionsResource(self)
+
+ @cached_property
+ def bookkeeping_accounts(self) -> BookkeepingAccountsResource:
+ from .resources.bookkeeping_accounts import BookkeepingAccountsResource
+
+ return BookkeepingAccountsResource(self)
+
+ @cached_property
+ def bookkeeping_entry_sets(self) -> BookkeepingEntrySetsResource:
+ from .resources.bookkeeping_entry_sets import BookkeepingEntrySetsResource
+
+ return BookkeepingEntrySetsResource(self)
+
+ @cached_property
+ def bookkeeping_entries(self) -> BookkeepingEntriesResource:
+ from .resources.bookkeeping_entries import BookkeepingEntriesResource
+
+ return BookkeepingEntriesResource(self)
+
+ @cached_property
+ def groups(self) -> GroupsResource:
+ from .resources.groups import GroupsResource
+
+ return GroupsResource(self)
+
+ @cached_property
+ def oauth_applications(self) -> OAuthApplicationsResource:
+ from .resources.oauth_applications import OAuthApplicationsResource
+
+ return OAuthApplicationsResource(self)
+
+ @cached_property
+ def oauth_connections(self) -> OAuthConnectionsResource:
+ from .resources.oauth_connections import OAuthConnectionsResource
+
+ return OAuthConnectionsResource(self)
+
+ @cached_property
+ def oauth_tokens(self) -> OAuthTokensResource:
+ from .resources.oauth_tokens import OAuthTokensResource
+
+ return OAuthTokensResource(self)
+
+ @cached_property
+ def intrafi_account_enrollments(self) -> IntrafiAccountEnrollmentsResource:
+ from .resources.intrafi_account_enrollments import IntrafiAccountEnrollmentsResource
+
+ return IntrafiAccountEnrollmentsResource(self)
+
+ @cached_property
+ def intrafi_balances(self) -> IntrafiBalancesResource:
+ from .resources.intrafi_balances import IntrafiBalancesResource
+
+ return IntrafiBalancesResource(self)
+
+ @cached_property
+ def intrafi_exclusions(self) -> IntrafiExclusionsResource:
+ from .resources.intrafi_exclusions import IntrafiExclusionsResource
+
+ return IntrafiExclusionsResource(self)
+
+ @cached_property
+ def card_tokens(self) -> CardTokensResource:
+ from .resources.card_tokens import CardTokensResource
+
+ return CardTokensResource(self)
+
+ @cached_property
+ def card_push_transfers(self) -> CardPushTransfersResource:
+ from .resources.card_push_transfers import CardPushTransfersResource
+
+ return CardPushTransfersResource(self)
+
+ @cached_property
+ def card_validations(self) -> CardValidationsResource:
+ from .resources.card_validations import CardValidationsResource
+
+ return CardValidationsResource(self)
+
+ @cached_property
+ def simulations(self) -> SimulationsResource:
+ from .resources.simulations import SimulationsResource
+
+ return SimulationsResource(self)
+
+ @cached_property
+ def webhooks(self) -> Webhooks:
+ from .resources.webhooks import Webhooks
+
+ return Webhooks(self)
+
+ @cached_property
+ def with_raw_response(self) -> IncreaseWithRawResponse:
+ return IncreaseWithRawResponse(self)
+
+ @cached_property
+ def with_streaming_response(self) -> IncreaseWithStreamedResponse:
+ return IncreaseWithStreamedResponse(self)
@property
@override
@@ -479,69 +1097,6 @@ def _make_status_error(
class AsyncIncrease(AsyncAPIClient):
- accounts: accounts.AsyncAccountsResource
- account_numbers: account_numbers.AsyncAccountNumbersResource
- account_transfers: account_transfers.AsyncAccountTransfersResource
- cards: cards.AsyncCardsResource
- card_payments: card_payments.AsyncCardPaymentsResource
- card_purchase_supplements: card_purchase_supplements.AsyncCardPurchaseSupplementsResource
- card_disputes: card_disputes.AsyncCardDisputesResource
- physical_cards: physical_cards.AsyncPhysicalCardsResource
- digital_card_profiles: digital_card_profiles.AsyncDigitalCardProfilesResource
- physical_card_profiles: physical_card_profiles.AsyncPhysicalCardProfilesResource
- digital_wallet_tokens: digital_wallet_tokens.AsyncDigitalWalletTokensResource
- transactions: transactions.AsyncTransactionsResource
- pending_transactions: pending_transactions.AsyncPendingTransactionsResource
- declined_transactions: declined_transactions.AsyncDeclinedTransactionsResource
- ach_transfers: ach_transfers.AsyncACHTransfersResource
- ach_prenotifications: ach_prenotifications.AsyncACHPrenotificationsResource
- inbound_ach_transfers: inbound_ach_transfers.AsyncInboundACHTransfersResource
- wire_transfers: wire_transfers.AsyncWireTransfersResource
- inbound_wire_transfers: inbound_wire_transfers.AsyncInboundWireTransfersResource
- wire_drawdown_requests: wire_drawdown_requests.AsyncWireDrawdownRequestsResource
- inbound_wire_drawdown_requests: inbound_wire_drawdown_requests.AsyncInboundWireDrawdownRequestsResource
- check_transfers: check_transfers.AsyncCheckTransfersResource
- inbound_check_deposits: inbound_check_deposits.AsyncInboundCheckDepositsResource
- real_time_payments_transfers: real_time_payments_transfers.AsyncRealTimePaymentsTransfersResource
- inbound_real_time_payments_transfers: (
- inbound_real_time_payments_transfers.AsyncInboundRealTimePaymentsTransfersResource
- )
- fednow_transfers: fednow_transfers.AsyncFednowTransfersResource
- inbound_fednow_transfers: inbound_fednow_transfers.AsyncInboundFednowTransfersResource
- check_deposits: check_deposits.AsyncCheckDepositsResource
- lockboxes: lockboxes.AsyncLockboxesResource
- inbound_mail_items: inbound_mail_items.AsyncInboundMailItemsResource
- routing_numbers: routing_numbers.AsyncRoutingNumbersResource
- external_accounts: external_accounts.AsyncExternalAccountsResource
- entities: entities.AsyncEntitiesResource
- supplemental_documents: supplemental_documents.AsyncSupplementalDocumentsResource
- programs: programs.AsyncProgramsResource
- account_statements: account_statements.AsyncAccountStatementsResource
- files: files.AsyncFilesResource
- file_links: file_links.AsyncFileLinksResource
- documents: documents.AsyncDocumentsResource
- exports: exports.AsyncExportsResource
- events: events.AsyncEventsResource
- event_subscriptions: event_subscriptions.AsyncEventSubscriptionsResource
- real_time_decisions: real_time_decisions.AsyncRealTimeDecisionsResource
- bookkeeping_accounts: bookkeeping_accounts.AsyncBookkeepingAccountsResource
- bookkeeping_entry_sets: bookkeeping_entry_sets.AsyncBookkeepingEntrySetsResource
- bookkeeping_entries: bookkeeping_entries.AsyncBookkeepingEntriesResource
- groups: groups.AsyncGroupsResource
- oauth_applications: oauth_applications.AsyncOAuthApplicationsResource
- oauth_connections: oauth_connections.AsyncOAuthConnectionsResource
- oauth_tokens: oauth_tokens.AsyncOAuthTokensResource
- intrafi_account_enrollments: intrafi_account_enrollments.AsyncIntrafiAccountEnrollmentsResource
- intrafi_balances: intrafi_balances.AsyncIntrafiBalancesResource
- intrafi_exclusions: intrafi_exclusions.AsyncIntrafiExclusionsResource
- card_tokens: card_tokens.AsyncCardTokensResource
- card_push_transfers: card_push_transfers.AsyncCardPushTransfersResource
- card_validations: card_validations.AsyncCardValidationsResource
- simulations: simulations.AsyncSimulationsResource
- webhooks: webhooks.AsyncWebhooks
- with_raw_response: AsyncIncreaseWithRawResponse
- with_streaming_response: AsyncIncreaseWithStreamedResponse
-
# client options
api_key: str
webhook_secret: str | None
@@ -630,157 +1185,442 @@ def __init__(
self._idempotency_header = "Idempotency-Key"
- self.accounts = accounts.AsyncAccountsResource(self)
- self.account_numbers = account_numbers.AsyncAccountNumbersResource(self)
- self.account_transfers = account_transfers.AsyncAccountTransfersResource(self)
- self.cards = cards.AsyncCardsResource(self)
- self.card_payments = card_payments.AsyncCardPaymentsResource(self)
- self.card_purchase_supplements = card_purchase_supplements.AsyncCardPurchaseSupplementsResource(self)
- self.card_disputes = card_disputes.AsyncCardDisputesResource(self)
- self.physical_cards = physical_cards.AsyncPhysicalCardsResource(self)
- self.digital_card_profiles = digital_card_profiles.AsyncDigitalCardProfilesResource(self)
- self.physical_card_profiles = physical_card_profiles.AsyncPhysicalCardProfilesResource(self)
- self.digital_wallet_tokens = digital_wallet_tokens.AsyncDigitalWalletTokensResource(self)
- self.transactions = transactions.AsyncTransactionsResource(self)
- self.pending_transactions = pending_transactions.AsyncPendingTransactionsResource(self)
- self.declined_transactions = declined_transactions.AsyncDeclinedTransactionsResource(self)
- self.ach_transfers = ach_transfers.AsyncACHTransfersResource(self)
- self.ach_prenotifications = ach_prenotifications.AsyncACHPrenotificationsResource(self)
- self.inbound_ach_transfers = inbound_ach_transfers.AsyncInboundACHTransfersResource(self)
- self.wire_transfers = wire_transfers.AsyncWireTransfersResource(self)
- self.inbound_wire_transfers = inbound_wire_transfers.AsyncInboundWireTransfersResource(self)
- self.wire_drawdown_requests = wire_drawdown_requests.AsyncWireDrawdownRequestsResource(self)
- self.inbound_wire_drawdown_requests = inbound_wire_drawdown_requests.AsyncInboundWireDrawdownRequestsResource(
- self
- )
- self.check_transfers = check_transfers.AsyncCheckTransfersResource(self)
- self.inbound_check_deposits = inbound_check_deposits.AsyncInboundCheckDepositsResource(self)
- self.real_time_payments_transfers = real_time_payments_transfers.AsyncRealTimePaymentsTransfersResource(self)
- self.inbound_real_time_payments_transfers = (
- inbound_real_time_payments_transfers.AsyncInboundRealTimePaymentsTransfersResource(self)
- )
- self.fednow_transfers = fednow_transfers.AsyncFednowTransfersResource(self)
- self.inbound_fednow_transfers = inbound_fednow_transfers.AsyncInboundFednowTransfersResource(self)
- self.check_deposits = check_deposits.AsyncCheckDepositsResource(self)
- self.lockboxes = lockboxes.AsyncLockboxesResource(self)
- self.inbound_mail_items = inbound_mail_items.AsyncInboundMailItemsResource(self)
- self.routing_numbers = routing_numbers.AsyncRoutingNumbersResource(self)
- self.external_accounts = external_accounts.AsyncExternalAccountsResource(self)
- self.entities = entities.AsyncEntitiesResource(self)
- self.supplemental_documents = supplemental_documents.AsyncSupplementalDocumentsResource(self)
- self.programs = programs.AsyncProgramsResource(self)
- self.account_statements = account_statements.AsyncAccountStatementsResource(self)
- self.files = files.AsyncFilesResource(self)
- self.file_links = file_links.AsyncFileLinksResource(self)
- self.documents = documents.AsyncDocumentsResource(self)
- self.exports = exports.AsyncExportsResource(self)
- self.events = events.AsyncEventsResource(self)
- self.event_subscriptions = event_subscriptions.AsyncEventSubscriptionsResource(self)
- self.real_time_decisions = real_time_decisions.AsyncRealTimeDecisionsResource(self)
- self.bookkeeping_accounts = bookkeeping_accounts.AsyncBookkeepingAccountsResource(self)
- self.bookkeeping_entry_sets = bookkeeping_entry_sets.AsyncBookkeepingEntrySetsResource(self)
- self.bookkeeping_entries = bookkeeping_entries.AsyncBookkeepingEntriesResource(self)
- self.groups = groups.AsyncGroupsResource(self)
- self.oauth_applications = oauth_applications.AsyncOAuthApplicationsResource(self)
- self.oauth_connections = oauth_connections.AsyncOAuthConnectionsResource(self)
- self.oauth_tokens = oauth_tokens.AsyncOAuthTokensResource(self)
- self.intrafi_account_enrollments = intrafi_account_enrollments.AsyncIntrafiAccountEnrollmentsResource(self)
- self.intrafi_balances = intrafi_balances.AsyncIntrafiBalancesResource(self)
- self.intrafi_exclusions = intrafi_exclusions.AsyncIntrafiExclusionsResource(self)
- self.card_tokens = card_tokens.AsyncCardTokensResource(self)
- self.card_push_transfers = card_push_transfers.AsyncCardPushTransfersResource(self)
- self.card_validations = card_validations.AsyncCardValidationsResource(self)
- self.simulations = simulations.AsyncSimulationsResource(self)
- self.webhooks = webhooks.AsyncWebhooks(self)
- self.with_raw_response = AsyncIncreaseWithRawResponse(self)
- self.with_streaming_response = AsyncIncreaseWithStreamedResponse(self)
+ @cached_property
+ def accounts(self) -> AsyncAccountsResource:
+ from .resources.accounts import AsyncAccountsResource
- @property
- @override
- def qs(self) -> Querystring:
- return Querystring(nested_format="dots", array_format="comma")
+ return AsyncAccountsResource(self)
- @property
- @override
- def auth_headers(self) -> dict[str, str]:
- api_key = self.api_key
- return {"Authorization": f"Bearer {api_key}"}
+ @cached_property
+ def account_numbers(self) -> AsyncAccountNumbersResource:
+ from .resources.account_numbers import AsyncAccountNumbersResource
- @property
- @override
- def default_headers(self) -> dict[str, str | Omit]:
- return {
- **super().default_headers,
- "X-Stainless-Async": f"async:{get_async_library()}",
- **self._custom_headers,
- }
+ return AsyncAccountNumbersResource(self)
- def copy(
- self,
- *,
- api_key: str | None = None,
- webhook_secret: str | None = None,
- environment: Literal["production", "sandbox"] | None = None,
- base_url: str | httpx.URL | None = None,
- timeout: float | Timeout | None | NotGiven = not_given,
- http_client: httpx.AsyncClient | None = None,
- max_retries: int | NotGiven = not_given,
- default_headers: Mapping[str, str] | None = None,
- set_default_headers: Mapping[str, str] | None = None,
- default_query: Mapping[str, object] | None = None,
- set_default_query: Mapping[str, object] | None = None,
- _extra_kwargs: Mapping[str, Any] = {},
- ) -> Self:
- """
- Create a new client instance re-using the same options given to the current client with optional overriding.
- """
- if default_headers is not None and set_default_headers is not None:
- raise ValueError("The `default_headers` and `set_default_headers` arguments are mutually exclusive")
+ @cached_property
+ def account_transfers(self) -> AsyncAccountTransfersResource:
+ from .resources.account_transfers import AsyncAccountTransfersResource
- if default_query is not None and set_default_query is not None:
- raise ValueError("The `default_query` and `set_default_query` arguments are mutually exclusive")
+ return AsyncAccountTransfersResource(self)
- headers = self._custom_headers
- if default_headers is not None:
- headers = {**headers, **default_headers}
- elif set_default_headers is not None:
- headers = set_default_headers
+ @cached_property
+ def cards(self) -> AsyncCardsResource:
+ from .resources.cards import AsyncCardsResource
- params = self._custom_query
- if default_query is not None:
- params = {**params, **default_query}
- elif set_default_query is not None:
- params = set_default_query
+ return AsyncCardsResource(self)
- http_client = http_client or self._client
- return self.__class__(
- api_key=api_key or self.api_key,
- webhook_secret=webhook_secret or self.webhook_secret,
- base_url=base_url or self.base_url,
- environment=environment or self._environment,
- timeout=self.timeout if isinstance(timeout, NotGiven) else timeout,
- http_client=http_client,
- max_retries=max_retries if is_given(max_retries) else self.max_retries,
- default_headers=headers,
- default_query=params,
- **_extra_kwargs,
- )
+ @cached_property
+ def card_payments(self) -> AsyncCardPaymentsResource:
+ from .resources.card_payments import AsyncCardPaymentsResource
- # Alias for `copy` for nicer inline usage, e.g.
- # client.with_options(timeout=10).foo.create(...)
- with_options = copy
+ return AsyncCardPaymentsResource(self)
- @override
- def _make_status_error(
- self,
- err_msg: str,
- *,
- body: object,
- response: httpx.Response,
- ) -> APIStatusError:
- type_ = body.get("type") if is_mapping(body) else None
- if type_ == "invalid_parameters_error":
- return _exceptions.InvalidParametersError(err_msg, response=response, body=body)
+ @cached_property
+ def card_purchase_supplements(self) -> AsyncCardPurchaseSupplementsResource:
+ from .resources.card_purchase_supplements import AsyncCardPurchaseSupplementsResource
+
+ return AsyncCardPurchaseSupplementsResource(self)
+
+ @cached_property
+ def card_disputes(self) -> AsyncCardDisputesResource:
+ from .resources.card_disputes import AsyncCardDisputesResource
+
+ return AsyncCardDisputesResource(self)
+
+ @cached_property
+ def physical_cards(self) -> AsyncPhysicalCardsResource:
+ from .resources.physical_cards import AsyncPhysicalCardsResource
+
+ return AsyncPhysicalCardsResource(self)
+
+ @cached_property
+ def digital_card_profiles(self) -> AsyncDigitalCardProfilesResource:
+ from .resources.digital_card_profiles import AsyncDigitalCardProfilesResource
+
+ return AsyncDigitalCardProfilesResource(self)
+
+ @cached_property
+ def physical_card_profiles(self) -> AsyncPhysicalCardProfilesResource:
+ from .resources.physical_card_profiles import AsyncPhysicalCardProfilesResource
+
+ return AsyncPhysicalCardProfilesResource(self)
+
+ @cached_property
+ def digital_wallet_tokens(self) -> AsyncDigitalWalletTokensResource:
+ from .resources.digital_wallet_tokens import AsyncDigitalWalletTokensResource
+
+ return AsyncDigitalWalletTokensResource(self)
+
+ @cached_property
+ def transactions(self) -> AsyncTransactionsResource:
+ from .resources.transactions import AsyncTransactionsResource
+
+ return AsyncTransactionsResource(self)
+
+ @cached_property
+ def pending_transactions(self) -> AsyncPendingTransactionsResource:
+ from .resources.pending_transactions import AsyncPendingTransactionsResource
+
+ return AsyncPendingTransactionsResource(self)
+
+ @cached_property
+ def declined_transactions(self) -> AsyncDeclinedTransactionsResource:
+ from .resources.declined_transactions import AsyncDeclinedTransactionsResource
+
+ return AsyncDeclinedTransactionsResource(self)
+
+ @cached_property
+ def ach_transfers(self) -> AsyncACHTransfersResource:
+ from .resources.ach_transfers import AsyncACHTransfersResource
+
+ return AsyncACHTransfersResource(self)
+
+ @cached_property
+ def ach_prenotifications(self) -> AsyncACHPrenotificationsResource:
+ from .resources.ach_prenotifications import AsyncACHPrenotificationsResource
+
+ return AsyncACHPrenotificationsResource(self)
+
+ @cached_property
+ def inbound_ach_transfers(self) -> AsyncInboundACHTransfersResource:
+ from .resources.inbound_ach_transfers import AsyncInboundACHTransfersResource
+
+ return AsyncInboundACHTransfersResource(self)
+
+ @cached_property
+ def wire_transfers(self) -> AsyncWireTransfersResource:
+ from .resources.wire_transfers import AsyncWireTransfersResource
+
+ return AsyncWireTransfersResource(self)
+
+ @cached_property
+ def inbound_wire_transfers(self) -> AsyncInboundWireTransfersResource:
+ from .resources.inbound_wire_transfers import AsyncInboundWireTransfersResource
+
+ return AsyncInboundWireTransfersResource(self)
+
+ @cached_property
+ def wire_drawdown_requests(self) -> AsyncWireDrawdownRequestsResource:
+ from .resources.wire_drawdown_requests import AsyncWireDrawdownRequestsResource
+
+ return AsyncWireDrawdownRequestsResource(self)
+
+ @cached_property
+ def inbound_wire_drawdown_requests(self) -> AsyncInboundWireDrawdownRequestsResource:
+ from .resources.inbound_wire_drawdown_requests import AsyncInboundWireDrawdownRequestsResource
+
+ return AsyncInboundWireDrawdownRequestsResource(self)
+
+ @cached_property
+ def check_transfers(self) -> AsyncCheckTransfersResource:
+ from .resources.check_transfers import AsyncCheckTransfersResource
+
+ return AsyncCheckTransfersResource(self)
+
+ @cached_property
+ def inbound_check_deposits(self) -> AsyncInboundCheckDepositsResource:
+ from .resources.inbound_check_deposits import AsyncInboundCheckDepositsResource
+
+ return AsyncInboundCheckDepositsResource(self)
+
+ @cached_property
+ def real_time_payments_transfers(self) -> AsyncRealTimePaymentsTransfersResource:
+ from .resources.real_time_payments_transfers import AsyncRealTimePaymentsTransfersResource
+
+ return AsyncRealTimePaymentsTransfersResource(self)
+
+ @cached_property
+ def inbound_real_time_payments_transfers(self) -> AsyncInboundRealTimePaymentsTransfersResource:
+ from .resources.inbound_real_time_payments_transfers import AsyncInboundRealTimePaymentsTransfersResource
+
+ return AsyncInboundRealTimePaymentsTransfersResource(self)
+
+ @cached_property
+ def fednow_transfers(self) -> AsyncFednowTransfersResource:
+ from .resources.fednow_transfers import AsyncFednowTransfersResource
+
+ return AsyncFednowTransfersResource(self)
+
+ @cached_property
+ def inbound_fednow_transfers(self) -> AsyncInboundFednowTransfersResource:
+ from .resources.inbound_fednow_transfers import AsyncInboundFednowTransfersResource
+
+ return AsyncInboundFednowTransfersResource(self)
+
+ @cached_property
+ def check_deposits(self) -> AsyncCheckDepositsResource:
+ from .resources.check_deposits import AsyncCheckDepositsResource
+
+ return AsyncCheckDepositsResource(self)
+
+ @cached_property
+ def lockboxes(self) -> AsyncLockboxesResource:
+ from .resources.lockboxes import AsyncLockboxesResource
+
+ return AsyncLockboxesResource(self)
+
+ @cached_property
+ def inbound_mail_items(self) -> AsyncInboundMailItemsResource:
+ from .resources.inbound_mail_items import AsyncInboundMailItemsResource
+
+ return AsyncInboundMailItemsResource(self)
+
+ @cached_property
+ def routing_numbers(self) -> AsyncRoutingNumbersResource:
+ from .resources.routing_numbers import AsyncRoutingNumbersResource
+
+ return AsyncRoutingNumbersResource(self)
+
+ @cached_property
+ def external_accounts(self) -> AsyncExternalAccountsResource:
+ from .resources.external_accounts import AsyncExternalAccountsResource
+
+ return AsyncExternalAccountsResource(self)
+
+ @cached_property
+ def entities(self) -> AsyncEntitiesResource:
+ from .resources.entities import AsyncEntitiesResource
+
+ return AsyncEntitiesResource(self)
+
+ @cached_property
+ def supplemental_documents(self) -> AsyncSupplementalDocumentsResource:
+ from .resources.supplemental_documents import AsyncSupplementalDocumentsResource
+
+ return AsyncSupplementalDocumentsResource(self)
+
+ @cached_property
+ def programs(self) -> AsyncProgramsResource:
+ from .resources.programs import AsyncProgramsResource
+
+ return AsyncProgramsResource(self)
+
+ @cached_property
+ def account_statements(self) -> AsyncAccountStatementsResource:
+ from .resources.account_statements import AsyncAccountStatementsResource
+
+ return AsyncAccountStatementsResource(self)
+
+ @cached_property
+ def files(self) -> AsyncFilesResource:
+ from .resources.files import AsyncFilesResource
+
+ return AsyncFilesResource(self)
+
+ @cached_property
+ def file_links(self) -> AsyncFileLinksResource:
+ from .resources.file_links import AsyncFileLinksResource
+
+ return AsyncFileLinksResource(self)
+
+ @cached_property
+ def exports(self) -> AsyncExportsResource:
+ from .resources.exports import AsyncExportsResource
+
+ return AsyncExportsResource(self)
+
+ @cached_property
+ def events(self) -> AsyncEventsResource:
+ from .resources.events import AsyncEventsResource
+
+ return AsyncEventsResource(self)
+
+ @cached_property
+ def event_subscriptions(self) -> AsyncEventSubscriptionsResource:
+ from .resources.event_subscriptions import AsyncEventSubscriptionsResource
+
+ return AsyncEventSubscriptionsResource(self)
+
+ @cached_property
+ def real_time_decisions(self) -> AsyncRealTimeDecisionsResource:
+ from .resources.real_time_decisions import AsyncRealTimeDecisionsResource
+
+ return AsyncRealTimeDecisionsResource(self)
+
+ @cached_property
+ def bookkeeping_accounts(self) -> AsyncBookkeepingAccountsResource:
+ from .resources.bookkeeping_accounts import AsyncBookkeepingAccountsResource
+
+ return AsyncBookkeepingAccountsResource(self)
+
+ @cached_property
+ def bookkeeping_entry_sets(self) -> AsyncBookkeepingEntrySetsResource:
+ from .resources.bookkeeping_entry_sets import AsyncBookkeepingEntrySetsResource
+
+ return AsyncBookkeepingEntrySetsResource(self)
+
+ @cached_property
+ def bookkeeping_entries(self) -> AsyncBookkeepingEntriesResource:
+ from .resources.bookkeeping_entries import AsyncBookkeepingEntriesResource
+
+ return AsyncBookkeepingEntriesResource(self)
+
+ @cached_property
+ def groups(self) -> AsyncGroupsResource:
+ from .resources.groups import AsyncGroupsResource
+
+ return AsyncGroupsResource(self)
+
+ @cached_property
+ def oauth_applications(self) -> AsyncOAuthApplicationsResource:
+ from .resources.oauth_applications import AsyncOAuthApplicationsResource
+
+ return AsyncOAuthApplicationsResource(self)
+
+ @cached_property
+ def oauth_connections(self) -> AsyncOAuthConnectionsResource:
+ from .resources.oauth_connections import AsyncOAuthConnectionsResource
+
+ return AsyncOAuthConnectionsResource(self)
+
+ @cached_property
+ def oauth_tokens(self) -> AsyncOAuthTokensResource:
+ from .resources.oauth_tokens import AsyncOAuthTokensResource
+
+ return AsyncOAuthTokensResource(self)
+
+ @cached_property
+ def intrafi_account_enrollments(self) -> AsyncIntrafiAccountEnrollmentsResource:
+ from .resources.intrafi_account_enrollments import AsyncIntrafiAccountEnrollmentsResource
+
+ return AsyncIntrafiAccountEnrollmentsResource(self)
+
+ @cached_property
+ def intrafi_balances(self) -> AsyncIntrafiBalancesResource:
+ from .resources.intrafi_balances import AsyncIntrafiBalancesResource
+
+ return AsyncIntrafiBalancesResource(self)
+
+ @cached_property
+ def intrafi_exclusions(self) -> AsyncIntrafiExclusionsResource:
+ from .resources.intrafi_exclusions import AsyncIntrafiExclusionsResource
+
+ return AsyncIntrafiExclusionsResource(self)
+
+ @cached_property
+ def card_tokens(self) -> AsyncCardTokensResource:
+ from .resources.card_tokens import AsyncCardTokensResource
+
+ return AsyncCardTokensResource(self)
+
+ @cached_property
+ def card_push_transfers(self) -> AsyncCardPushTransfersResource:
+ from .resources.card_push_transfers import AsyncCardPushTransfersResource
+
+ return AsyncCardPushTransfersResource(self)
+
+ @cached_property
+ def card_validations(self) -> AsyncCardValidationsResource:
+ from .resources.card_validations import AsyncCardValidationsResource
+
+ return AsyncCardValidationsResource(self)
+
+ @cached_property
+ def simulations(self) -> AsyncSimulationsResource:
+ from .resources.simulations import AsyncSimulationsResource
+
+ return AsyncSimulationsResource(self)
+
+ @cached_property
+ def webhooks(self) -> AsyncWebhooks:
+ from .resources.webhooks import AsyncWebhooks
+
+ return AsyncWebhooks(self)
+
+ @cached_property
+ def with_raw_response(self) -> AsyncIncreaseWithRawResponse:
+ return AsyncIncreaseWithRawResponse(self)
+
+ @cached_property
+ def with_streaming_response(self) -> AsyncIncreaseWithStreamedResponse:
+ return AsyncIncreaseWithStreamedResponse(self)
+
+ @property
+ @override
+ def qs(self) -> Querystring:
+ return Querystring(nested_format="dots", array_format="comma")
+
+ @property
+ @override
+ def auth_headers(self) -> dict[str, str]:
+ api_key = self.api_key
+ return {"Authorization": f"Bearer {api_key}"}
+
+ @property
+ @override
+ def default_headers(self) -> dict[str, str | Omit]:
+ return {
+ **super().default_headers,
+ "X-Stainless-Async": f"async:{get_async_library()}",
+ **self._custom_headers,
+ }
+
+ def copy(
+ self,
+ *,
+ api_key: str | None = None,
+ webhook_secret: str | None = None,
+ environment: Literal["production", "sandbox"] | None = None,
+ base_url: str | httpx.URL | None = None,
+ timeout: float | Timeout | None | NotGiven = not_given,
+ http_client: httpx.AsyncClient | None = None,
+ max_retries: int | NotGiven = not_given,
+ default_headers: Mapping[str, str] | None = None,
+ set_default_headers: Mapping[str, str] | None = None,
+ default_query: Mapping[str, object] | None = None,
+ set_default_query: Mapping[str, object] | None = None,
+ _extra_kwargs: Mapping[str, Any] = {},
+ ) -> Self:
+ """
+ Create a new client instance re-using the same options given to the current client with optional overriding.
+ """
+ if default_headers is not None and set_default_headers is not None:
+ raise ValueError("The `default_headers` and `set_default_headers` arguments are mutually exclusive")
+
+ if default_query is not None and set_default_query is not None:
+ raise ValueError("The `default_query` and `set_default_query` arguments are mutually exclusive")
+
+ headers = self._custom_headers
+ if default_headers is not None:
+ headers = {**headers, **default_headers}
+ elif set_default_headers is not None:
+ headers = set_default_headers
+
+ params = self._custom_query
+ if default_query is not None:
+ params = {**params, **default_query}
+ elif set_default_query is not None:
+ params = set_default_query
+
+ http_client = http_client or self._client
+ return self.__class__(
+ api_key=api_key or self.api_key,
+ webhook_secret=webhook_secret or self.webhook_secret,
+ base_url=base_url or self.base_url,
+ environment=environment or self._environment,
+ timeout=self.timeout if isinstance(timeout, NotGiven) else timeout,
+ http_client=http_client,
+ max_retries=max_retries if is_given(max_retries) else self.max_retries,
+ default_headers=headers,
+ default_query=params,
+ **_extra_kwargs,
+ )
+
+ # Alias for `copy` for nicer inline usage, e.g.
+ # client.with_options(timeout=10).foo.create(...)
+ with_options = copy
+
+ @override
+ def _make_status_error(
+ self,
+ err_msg: str,
+ *,
+ body: object,
+ response: httpx.Response,
+ ) -> APIStatusError:
+ type_ = body.get("type") if is_mapping(body) else None
+ if type_ == "invalid_parameters_error":
+ return _exceptions.InvalidParametersError(err_msg, response=response, body=body)
if type_ == "malformed_request_error":
return _exceptions.MalformedRequestError(err_msg, response=response, body=body)
@@ -850,513 +1690,1435 @@ def _make_status_error(
class IncreaseWithRawResponse:
+ _client: Increase
+
def __init__(self, client: Increase) -> None:
- self.accounts = accounts.AccountsResourceWithRawResponse(client.accounts)
- self.account_numbers = account_numbers.AccountNumbersResourceWithRawResponse(client.account_numbers)
- self.account_transfers = account_transfers.AccountTransfersResourceWithRawResponse(client.account_transfers)
- self.cards = cards.CardsResourceWithRawResponse(client.cards)
- self.card_payments = card_payments.CardPaymentsResourceWithRawResponse(client.card_payments)
- self.card_purchase_supplements = card_purchase_supplements.CardPurchaseSupplementsResourceWithRawResponse(
- client.card_purchase_supplements
- )
- self.card_disputes = card_disputes.CardDisputesResourceWithRawResponse(client.card_disputes)
- self.physical_cards = physical_cards.PhysicalCardsResourceWithRawResponse(client.physical_cards)
- self.digital_card_profiles = digital_card_profiles.DigitalCardProfilesResourceWithRawResponse(
- client.digital_card_profiles
- )
- self.physical_card_profiles = physical_card_profiles.PhysicalCardProfilesResourceWithRawResponse(
- client.physical_card_profiles
- )
- self.digital_wallet_tokens = digital_wallet_tokens.DigitalWalletTokensResourceWithRawResponse(
- client.digital_wallet_tokens
- )
- self.transactions = transactions.TransactionsResourceWithRawResponse(client.transactions)
- self.pending_transactions = pending_transactions.PendingTransactionsResourceWithRawResponse(
- client.pending_transactions
- )
- self.declined_transactions = declined_transactions.DeclinedTransactionsResourceWithRawResponse(
- client.declined_transactions
- )
- self.ach_transfers = ach_transfers.ACHTransfersResourceWithRawResponse(client.ach_transfers)
- self.ach_prenotifications = ach_prenotifications.ACHPrenotificationsResourceWithRawResponse(
- client.ach_prenotifications
- )
- self.inbound_ach_transfers = inbound_ach_transfers.InboundACHTransfersResourceWithRawResponse(
- client.inbound_ach_transfers
- )
- self.wire_transfers = wire_transfers.WireTransfersResourceWithRawResponse(client.wire_transfers)
- self.inbound_wire_transfers = inbound_wire_transfers.InboundWireTransfersResourceWithRawResponse(
- client.inbound_wire_transfers
- )
- self.wire_drawdown_requests = wire_drawdown_requests.WireDrawdownRequestsResourceWithRawResponse(
- client.wire_drawdown_requests
- )
- self.inbound_wire_drawdown_requests = (
- inbound_wire_drawdown_requests.InboundWireDrawdownRequestsResourceWithRawResponse(
- client.inbound_wire_drawdown_requests
- )
- )
- self.check_transfers = check_transfers.CheckTransfersResourceWithRawResponse(client.check_transfers)
- self.inbound_check_deposits = inbound_check_deposits.InboundCheckDepositsResourceWithRawResponse(
- client.inbound_check_deposits
- )
- self.real_time_payments_transfers = (
- real_time_payments_transfers.RealTimePaymentsTransfersResourceWithRawResponse(
- client.real_time_payments_transfers
- )
- )
- self.inbound_real_time_payments_transfers = (
- inbound_real_time_payments_transfers.InboundRealTimePaymentsTransfersResourceWithRawResponse(
- client.inbound_real_time_payments_transfers
- )
- )
- self.fednow_transfers = fednow_transfers.FednowTransfersResourceWithRawResponse(client.fednow_transfers)
- self.inbound_fednow_transfers = inbound_fednow_transfers.InboundFednowTransfersResourceWithRawResponse(
- client.inbound_fednow_transfers
- )
- self.check_deposits = check_deposits.CheckDepositsResourceWithRawResponse(client.check_deposits)
- self.lockboxes = lockboxes.LockboxesResourceWithRawResponse(client.lockboxes)
- self.inbound_mail_items = inbound_mail_items.InboundMailItemsResourceWithRawResponse(client.inbound_mail_items)
- self.routing_numbers = routing_numbers.RoutingNumbersResourceWithRawResponse(client.routing_numbers)
- self.external_accounts = external_accounts.ExternalAccountsResourceWithRawResponse(client.external_accounts)
- self.entities = entities.EntitiesResourceWithRawResponse(client.entities)
- self.supplemental_documents = supplemental_documents.SupplementalDocumentsResourceWithRawResponse(
- client.supplemental_documents
- )
- self.programs = programs.ProgramsResourceWithRawResponse(client.programs)
- self.account_statements = account_statements.AccountStatementsResourceWithRawResponse(client.account_statements)
- self.files = files.FilesResourceWithRawResponse(client.files)
- self.file_links = file_links.FileLinksResourceWithRawResponse(client.file_links)
- self.documents = documents.DocumentsResourceWithRawResponse(client.documents)
- self.exports = exports.ExportsResourceWithRawResponse(client.exports)
- self.events = events.EventsResourceWithRawResponse(client.events)
- self.event_subscriptions = event_subscriptions.EventSubscriptionsResourceWithRawResponse(
- client.event_subscriptions
- )
- self.real_time_decisions = real_time_decisions.RealTimeDecisionsResourceWithRawResponse(
- client.real_time_decisions
- )
- self.bookkeeping_accounts = bookkeeping_accounts.BookkeepingAccountsResourceWithRawResponse(
- client.bookkeeping_accounts
- )
- self.bookkeeping_entry_sets = bookkeeping_entry_sets.BookkeepingEntrySetsResourceWithRawResponse(
- client.bookkeeping_entry_sets
- )
- self.bookkeeping_entries = bookkeeping_entries.BookkeepingEntriesResourceWithRawResponse(
- client.bookkeeping_entries
- )
- self.groups = groups.GroupsResourceWithRawResponse(client.groups)
- self.oauth_applications = oauth_applications.OAuthApplicationsResourceWithRawResponse(client.oauth_applications)
- self.oauth_connections = oauth_connections.OAuthConnectionsResourceWithRawResponse(client.oauth_connections)
- self.oauth_tokens = oauth_tokens.OAuthTokensResourceWithRawResponse(client.oauth_tokens)
- self.intrafi_account_enrollments = intrafi_account_enrollments.IntrafiAccountEnrollmentsResourceWithRawResponse(
- client.intrafi_account_enrollments
- )
- self.intrafi_balances = intrafi_balances.IntrafiBalancesResourceWithRawResponse(client.intrafi_balances)
- self.intrafi_exclusions = intrafi_exclusions.IntrafiExclusionsResourceWithRawResponse(client.intrafi_exclusions)
- self.card_tokens = card_tokens.CardTokensResourceWithRawResponse(client.card_tokens)
- self.card_push_transfers = card_push_transfers.CardPushTransfersResourceWithRawResponse(
- client.card_push_transfers
- )
- self.card_validations = card_validations.CardValidationsResourceWithRawResponse(client.card_validations)
- self.simulations = simulations.SimulationsResourceWithRawResponse(client.simulations)
+ self._client = client
+ @cached_property
+ def accounts(self) -> AccountsResourceWithRawResponse:
+ from .resources.accounts import AccountsResourceWithRawResponse
-class AsyncIncreaseWithRawResponse:
- def __init__(self, client: AsyncIncrease) -> None:
- self.accounts = accounts.AsyncAccountsResourceWithRawResponse(client.accounts)
- self.account_numbers = account_numbers.AsyncAccountNumbersResourceWithRawResponse(client.account_numbers)
- self.account_transfers = account_transfers.AsyncAccountTransfersResourceWithRawResponse(
- client.account_transfers
- )
- self.cards = cards.AsyncCardsResourceWithRawResponse(client.cards)
- self.card_payments = card_payments.AsyncCardPaymentsResourceWithRawResponse(client.card_payments)
- self.card_purchase_supplements = card_purchase_supplements.AsyncCardPurchaseSupplementsResourceWithRawResponse(
- client.card_purchase_supplements
- )
- self.card_disputes = card_disputes.AsyncCardDisputesResourceWithRawResponse(client.card_disputes)
- self.physical_cards = physical_cards.AsyncPhysicalCardsResourceWithRawResponse(client.physical_cards)
- self.digital_card_profiles = digital_card_profiles.AsyncDigitalCardProfilesResourceWithRawResponse(
- client.digital_card_profiles
- )
- self.physical_card_profiles = physical_card_profiles.AsyncPhysicalCardProfilesResourceWithRawResponse(
- client.physical_card_profiles
- )
- self.digital_wallet_tokens = digital_wallet_tokens.AsyncDigitalWalletTokensResourceWithRawResponse(
- client.digital_wallet_tokens
- )
- self.transactions = transactions.AsyncTransactionsResourceWithRawResponse(client.transactions)
- self.pending_transactions = pending_transactions.AsyncPendingTransactionsResourceWithRawResponse(
- client.pending_transactions
- )
- self.declined_transactions = declined_transactions.AsyncDeclinedTransactionsResourceWithRawResponse(
- client.declined_transactions
- )
- self.ach_transfers = ach_transfers.AsyncACHTransfersResourceWithRawResponse(client.ach_transfers)
- self.ach_prenotifications = ach_prenotifications.AsyncACHPrenotificationsResourceWithRawResponse(
- client.ach_prenotifications
- )
- self.inbound_ach_transfers = inbound_ach_transfers.AsyncInboundACHTransfersResourceWithRawResponse(
- client.inbound_ach_transfers
- )
- self.wire_transfers = wire_transfers.AsyncWireTransfersResourceWithRawResponse(client.wire_transfers)
- self.inbound_wire_transfers = inbound_wire_transfers.AsyncInboundWireTransfersResourceWithRawResponse(
- client.inbound_wire_transfers
- )
- self.wire_drawdown_requests = wire_drawdown_requests.AsyncWireDrawdownRequestsResourceWithRawResponse(
- client.wire_drawdown_requests
- )
- self.inbound_wire_drawdown_requests = (
- inbound_wire_drawdown_requests.AsyncInboundWireDrawdownRequestsResourceWithRawResponse(
- client.inbound_wire_drawdown_requests
- )
- )
- self.check_transfers = check_transfers.AsyncCheckTransfersResourceWithRawResponse(client.check_transfers)
- self.inbound_check_deposits = inbound_check_deposits.AsyncInboundCheckDepositsResourceWithRawResponse(
- client.inbound_check_deposits
- )
- self.real_time_payments_transfers = (
- real_time_payments_transfers.AsyncRealTimePaymentsTransfersResourceWithRawResponse(
- client.real_time_payments_transfers
- )
- )
- self.inbound_real_time_payments_transfers = (
- inbound_real_time_payments_transfers.AsyncInboundRealTimePaymentsTransfersResourceWithRawResponse(
- client.inbound_real_time_payments_transfers
- )
- )
- self.fednow_transfers = fednow_transfers.AsyncFednowTransfersResourceWithRawResponse(client.fednow_transfers)
- self.inbound_fednow_transfers = inbound_fednow_transfers.AsyncInboundFednowTransfersResourceWithRawResponse(
- client.inbound_fednow_transfers
- )
- self.check_deposits = check_deposits.AsyncCheckDepositsResourceWithRawResponse(client.check_deposits)
- self.lockboxes = lockboxes.AsyncLockboxesResourceWithRawResponse(client.lockboxes)
- self.inbound_mail_items = inbound_mail_items.AsyncInboundMailItemsResourceWithRawResponse(
- client.inbound_mail_items
- )
- self.routing_numbers = routing_numbers.AsyncRoutingNumbersResourceWithRawResponse(client.routing_numbers)
- self.external_accounts = external_accounts.AsyncExternalAccountsResourceWithRawResponse(
- client.external_accounts
- )
- self.entities = entities.AsyncEntitiesResourceWithRawResponse(client.entities)
- self.supplemental_documents = supplemental_documents.AsyncSupplementalDocumentsResourceWithRawResponse(
- client.supplemental_documents
- )
- self.programs = programs.AsyncProgramsResourceWithRawResponse(client.programs)
- self.account_statements = account_statements.AsyncAccountStatementsResourceWithRawResponse(
- client.account_statements
- )
- self.files = files.AsyncFilesResourceWithRawResponse(client.files)
- self.file_links = file_links.AsyncFileLinksResourceWithRawResponse(client.file_links)
- self.documents = documents.AsyncDocumentsResourceWithRawResponse(client.documents)
- self.exports = exports.AsyncExportsResourceWithRawResponse(client.exports)
- self.events = events.AsyncEventsResourceWithRawResponse(client.events)
- self.event_subscriptions = event_subscriptions.AsyncEventSubscriptionsResourceWithRawResponse(
- client.event_subscriptions
- )
- self.real_time_decisions = real_time_decisions.AsyncRealTimeDecisionsResourceWithRawResponse(
- client.real_time_decisions
- )
- self.bookkeeping_accounts = bookkeeping_accounts.AsyncBookkeepingAccountsResourceWithRawResponse(
- client.bookkeeping_accounts
- )
- self.bookkeeping_entry_sets = bookkeeping_entry_sets.AsyncBookkeepingEntrySetsResourceWithRawResponse(
- client.bookkeeping_entry_sets
- )
- self.bookkeeping_entries = bookkeeping_entries.AsyncBookkeepingEntriesResourceWithRawResponse(
- client.bookkeeping_entries
- )
- self.groups = groups.AsyncGroupsResourceWithRawResponse(client.groups)
- self.oauth_applications = oauth_applications.AsyncOAuthApplicationsResourceWithRawResponse(
- client.oauth_applications
- )
- self.oauth_connections = oauth_connections.AsyncOAuthConnectionsResourceWithRawResponse(
- client.oauth_connections
- )
- self.oauth_tokens = oauth_tokens.AsyncOAuthTokensResourceWithRawResponse(client.oauth_tokens)
- self.intrafi_account_enrollments = (
- intrafi_account_enrollments.AsyncIntrafiAccountEnrollmentsResourceWithRawResponse(
- client.intrafi_account_enrollments
- )
- )
- self.intrafi_balances = intrafi_balances.AsyncIntrafiBalancesResourceWithRawResponse(client.intrafi_balances)
- self.intrafi_exclusions = intrafi_exclusions.AsyncIntrafiExclusionsResourceWithRawResponse(
- client.intrafi_exclusions
- )
- self.card_tokens = card_tokens.AsyncCardTokensResourceWithRawResponse(client.card_tokens)
- self.card_push_transfers = card_push_transfers.AsyncCardPushTransfersResourceWithRawResponse(
- client.card_push_transfers
- )
- self.card_validations = card_validations.AsyncCardValidationsResourceWithRawResponse(client.card_validations)
- self.simulations = simulations.AsyncSimulationsResourceWithRawResponse(client.simulations)
+ return AccountsResourceWithRawResponse(self._client.accounts)
+ @cached_property
+ def account_numbers(self) -> AccountNumbersResourceWithRawResponse:
+ from .resources.account_numbers import AccountNumbersResourceWithRawResponse
-class IncreaseWithStreamedResponse:
- def __init__(self, client: Increase) -> None:
- self.accounts = accounts.AccountsResourceWithStreamingResponse(client.accounts)
- self.account_numbers = account_numbers.AccountNumbersResourceWithStreamingResponse(client.account_numbers)
- self.account_transfers = account_transfers.AccountTransfersResourceWithStreamingResponse(
- client.account_transfers
- )
- self.cards = cards.CardsResourceWithStreamingResponse(client.cards)
- self.card_payments = card_payments.CardPaymentsResourceWithStreamingResponse(client.card_payments)
- self.card_purchase_supplements = card_purchase_supplements.CardPurchaseSupplementsResourceWithStreamingResponse(
- client.card_purchase_supplements
- )
- self.card_disputes = card_disputes.CardDisputesResourceWithStreamingResponse(client.card_disputes)
- self.physical_cards = physical_cards.PhysicalCardsResourceWithStreamingResponse(client.physical_cards)
- self.digital_card_profiles = digital_card_profiles.DigitalCardProfilesResourceWithStreamingResponse(
- client.digital_card_profiles
- )
- self.physical_card_profiles = physical_card_profiles.PhysicalCardProfilesResourceWithStreamingResponse(
- client.physical_card_profiles
- )
- self.digital_wallet_tokens = digital_wallet_tokens.DigitalWalletTokensResourceWithStreamingResponse(
- client.digital_wallet_tokens
- )
- self.transactions = transactions.TransactionsResourceWithStreamingResponse(client.transactions)
- self.pending_transactions = pending_transactions.PendingTransactionsResourceWithStreamingResponse(
- client.pending_transactions
- )
- self.declined_transactions = declined_transactions.DeclinedTransactionsResourceWithStreamingResponse(
- client.declined_transactions
- )
- self.ach_transfers = ach_transfers.ACHTransfersResourceWithStreamingResponse(client.ach_transfers)
- self.ach_prenotifications = ach_prenotifications.ACHPrenotificationsResourceWithStreamingResponse(
- client.ach_prenotifications
- )
- self.inbound_ach_transfers = inbound_ach_transfers.InboundACHTransfersResourceWithStreamingResponse(
- client.inbound_ach_transfers
- )
- self.wire_transfers = wire_transfers.WireTransfersResourceWithStreamingResponse(client.wire_transfers)
- self.inbound_wire_transfers = inbound_wire_transfers.InboundWireTransfersResourceWithStreamingResponse(
- client.inbound_wire_transfers
- )
- self.wire_drawdown_requests = wire_drawdown_requests.WireDrawdownRequestsResourceWithStreamingResponse(
- client.wire_drawdown_requests
- )
- self.inbound_wire_drawdown_requests = (
- inbound_wire_drawdown_requests.InboundWireDrawdownRequestsResourceWithStreamingResponse(
- client.inbound_wire_drawdown_requests
- )
- )
- self.check_transfers = check_transfers.CheckTransfersResourceWithStreamingResponse(client.check_transfers)
- self.inbound_check_deposits = inbound_check_deposits.InboundCheckDepositsResourceWithStreamingResponse(
- client.inbound_check_deposits
- )
- self.real_time_payments_transfers = (
- real_time_payments_transfers.RealTimePaymentsTransfersResourceWithStreamingResponse(
- client.real_time_payments_transfers
- )
- )
- self.inbound_real_time_payments_transfers = (
- inbound_real_time_payments_transfers.InboundRealTimePaymentsTransfersResourceWithStreamingResponse(
- client.inbound_real_time_payments_transfers
- )
- )
- self.fednow_transfers = fednow_transfers.FednowTransfersResourceWithStreamingResponse(client.fednow_transfers)
- self.inbound_fednow_transfers = inbound_fednow_transfers.InboundFednowTransfersResourceWithStreamingResponse(
- client.inbound_fednow_transfers
- )
- self.check_deposits = check_deposits.CheckDepositsResourceWithStreamingResponse(client.check_deposits)
- self.lockboxes = lockboxes.LockboxesResourceWithStreamingResponse(client.lockboxes)
- self.inbound_mail_items = inbound_mail_items.InboundMailItemsResourceWithStreamingResponse(
- client.inbound_mail_items
- )
- self.routing_numbers = routing_numbers.RoutingNumbersResourceWithStreamingResponse(client.routing_numbers)
- self.external_accounts = external_accounts.ExternalAccountsResourceWithStreamingResponse(
- client.external_accounts
- )
- self.entities = entities.EntitiesResourceWithStreamingResponse(client.entities)
- self.supplemental_documents = supplemental_documents.SupplementalDocumentsResourceWithStreamingResponse(
- client.supplemental_documents
- )
- self.programs = programs.ProgramsResourceWithStreamingResponse(client.programs)
- self.account_statements = account_statements.AccountStatementsResourceWithStreamingResponse(
- client.account_statements
- )
- self.files = files.FilesResourceWithStreamingResponse(client.files)
- self.file_links = file_links.FileLinksResourceWithStreamingResponse(client.file_links)
- self.documents = documents.DocumentsResourceWithStreamingResponse(client.documents)
- self.exports = exports.ExportsResourceWithStreamingResponse(client.exports)
- self.events = events.EventsResourceWithStreamingResponse(client.events)
- self.event_subscriptions = event_subscriptions.EventSubscriptionsResourceWithStreamingResponse(
- client.event_subscriptions
- )
- self.real_time_decisions = real_time_decisions.RealTimeDecisionsResourceWithStreamingResponse(
- client.real_time_decisions
- )
- self.bookkeeping_accounts = bookkeeping_accounts.BookkeepingAccountsResourceWithStreamingResponse(
- client.bookkeeping_accounts
- )
- self.bookkeeping_entry_sets = bookkeeping_entry_sets.BookkeepingEntrySetsResourceWithStreamingResponse(
- client.bookkeeping_entry_sets
- )
- self.bookkeeping_entries = bookkeeping_entries.BookkeepingEntriesResourceWithStreamingResponse(
- client.bookkeeping_entries
+ return AccountNumbersResourceWithRawResponse(self._client.account_numbers)
+
+ @cached_property
+ def account_transfers(self) -> AccountTransfersResourceWithRawResponse:
+ from .resources.account_transfers import AccountTransfersResourceWithRawResponse
+
+ return AccountTransfersResourceWithRawResponse(self._client.account_transfers)
+
+ @cached_property
+ def cards(self) -> CardsResourceWithRawResponse:
+ from .resources.cards import CardsResourceWithRawResponse
+
+ return CardsResourceWithRawResponse(self._client.cards)
+
+ @cached_property
+ def card_payments(self) -> CardPaymentsResourceWithRawResponse:
+ from .resources.card_payments import CardPaymentsResourceWithRawResponse
+
+ return CardPaymentsResourceWithRawResponse(self._client.card_payments)
+
+ @cached_property
+ def card_purchase_supplements(self) -> CardPurchaseSupplementsResourceWithRawResponse:
+ from .resources.card_purchase_supplements import CardPurchaseSupplementsResourceWithRawResponse
+
+ return CardPurchaseSupplementsResourceWithRawResponse(self._client.card_purchase_supplements)
+
+ @cached_property
+ def card_disputes(self) -> CardDisputesResourceWithRawResponse:
+ from .resources.card_disputes import CardDisputesResourceWithRawResponse
+
+ return CardDisputesResourceWithRawResponse(self._client.card_disputes)
+
+ @cached_property
+ def physical_cards(self) -> PhysicalCardsResourceWithRawResponse:
+ from .resources.physical_cards import PhysicalCardsResourceWithRawResponse
+
+ return PhysicalCardsResourceWithRawResponse(self._client.physical_cards)
+
+ @cached_property
+ def digital_card_profiles(self) -> DigitalCardProfilesResourceWithRawResponse:
+ from .resources.digital_card_profiles import DigitalCardProfilesResourceWithRawResponse
+
+ return DigitalCardProfilesResourceWithRawResponse(self._client.digital_card_profiles)
+
+ @cached_property
+ def physical_card_profiles(self) -> PhysicalCardProfilesResourceWithRawResponse:
+ from .resources.physical_card_profiles import PhysicalCardProfilesResourceWithRawResponse
+
+ return PhysicalCardProfilesResourceWithRawResponse(self._client.physical_card_profiles)
+
+ @cached_property
+ def digital_wallet_tokens(self) -> DigitalWalletTokensResourceWithRawResponse:
+ from .resources.digital_wallet_tokens import DigitalWalletTokensResourceWithRawResponse
+
+ return DigitalWalletTokensResourceWithRawResponse(self._client.digital_wallet_tokens)
+
+ @cached_property
+ def transactions(self) -> TransactionsResourceWithRawResponse:
+ from .resources.transactions import TransactionsResourceWithRawResponse
+
+ return TransactionsResourceWithRawResponse(self._client.transactions)
+
+ @cached_property
+ def pending_transactions(self) -> PendingTransactionsResourceWithRawResponse:
+ from .resources.pending_transactions import PendingTransactionsResourceWithRawResponse
+
+ return PendingTransactionsResourceWithRawResponse(self._client.pending_transactions)
+
+ @cached_property
+ def declined_transactions(self) -> DeclinedTransactionsResourceWithRawResponse:
+ from .resources.declined_transactions import DeclinedTransactionsResourceWithRawResponse
+
+ return DeclinedTransactionsResourceWithRawResponse(self._client.declined_transactions)
+
+ @cached_property
+ def ach_transfers(self) -> ACHTransfersResourceWithRawResponse:
+ from .resources.ach_transfers import ACHTransfersResourceWithRawResponse
+
+ return ACHTransfersResourceWithRawResponse(self._client.ach_transfers)
+
+ @cached_property
+ def ach_prenotifications(self) -> ACHPrenotificationsResourceWithRawResponse:
+ from .resources.ach_prenotifications import ACHPrenotificationsResourceWithRawResponse
+
+ return ACHPrenotificationsResourceWithRawResponse(self._client.ach_prenotifications)
+
+ @cached_property
+ def inbound_ach_transfers(self) -> InboundACHTransfersResourceWithRawResponse:
+ from .resources.inbound_ach_transfers import InboundACHTransfersResourceWithRawResponse
+
+ return InboundACHTransfersResourceWithRawResponse(self._client.inbound_ach_transfers)
+
+ @cached_property
+ def wire_transfers(self) -> WireTransfersResourceWithRawResponse:
+ from .resources.wire_transfers import WireTransfersResourceWithRawResponse
+
+ return WireTransfersResourceWithRawResponse(self._client.wire_transfers)
+
+ @cached_property
+ def inbound_wire_transfers(self) -> InboundWireTransfersResourceWithRawResponse:
+ from .resources.inbound_wire_transfers import InboundWireTransfersResourceWithRawResponse
+
+ return InboundWireTransfersResourceWithRawResponse(self._client.inbound_wire_transfers)
+
+ @cached_property
+ def wire_drawdown_requests(self) -> WireDrawdownRequestsResourceWithRawResponse:
+ from .resources.wire_drawdown_requests import WireDrawdownRequestsResourceWithRawResponse
+
+ return WireDrawdownRequestsResourceWithRawResponse(self._client.wire_drawdown_requests)
+
+ @cached_property
+ def inbound_wire_drawdown_requests(
+ self,
+ ) -> InboundWireDrawdownRequestsResourceWithRawResponse:
+ from .resources.inbound_wire_drawdown_requests import InboundWireDrawdownRequestsResourceWithRawResponse
+
+ return InboundWireDrawdownRequestsResourceWithRawResponse(self._client.inbound_wire_drawdown_requests)
+
+ @cached_property
+ def check_transfers(self) -> CheckTransfersResourceWithRawResponse:
+ from .resources.check_transfers import CheckTransfersResourceWithRawResponse
+
+ return CheckTransfersResourceWithRawResponse(self._client.check_transfers)
+
+ @cached_property
+ def inbound_check_deposits(self) -> InboundCheckDepositsResourceWithRawResponse:
+ from .resources.inbound_check_deposits import InboundCheckDepositsResourceWithRawResponse
+
+ return InboundCheckDepositsResourceWithRawResponse(self._client.inbound_check_deposits)
+
+ @cached_property
+ def real_time_payments_transfers(
+ self,
+ ) -> RealTimePaymentsTransfersResourceWithRawResponse:
+ from .resources.real_time_payments_transfers import RealTimePaymentsTransfersResourceWithRawResponse
+
+ return RealTimePaymentsTransfersResourceWithRawResponse(self._client.real_time_payments_transfers)
+
+ @cached_property
+ def inbound_real_time_payments_transfers(
+ self,
+ ) -> InboundRealTimePaymentsTransfersResourceWithRawResponse:
+ from .resources.inbound_real_time_payments_transfers import (
+ InboundRealTimePaymentsTransfersResourceWithRawResponse,
)
- self.groups = groups.GroupsResourceWithStreamingResponse(client.groups)
- self.oauth_applications = oauth_applications.OAuthApplicationsResourceWithStreamingResponse(
- client.oauth_applications
+
+ return InboundRealTimePaymentsTransfersResourceWithRawResponse(
+ self._client.inbound_real_time_payments_transfers
)
- self.oauth_connections = oauth_connections.OAuthConnectionsResourceWithStreamingResponse(
- client.oauth_connections
+
+ @cached_property
+ def fednow_transfers(self) -> FednowTransfersResourceWithRawResponse:
+ from .resources.fednow_transfers import FednowTransfersResourceWithRawResponse
+
+ return FednowTransfersResourceWithRawResponse(self._client.fednow_transfers)
+
+ @cached_property
+ def inbound_fednow_transfers(self) -> InboundFednowTransfersResourceWithRawResponse:
+ from .resources.inbound_fednow_transfers import InboundFednowTransfersResourceWithRawResponse
+
+ return InboundFednowTransfersResourceWithRawResponse(self._client.inbound_fednow_transfers)
+
+ @cached_property
+ def check_deposits(self) -> CheckDepositsResourceWithRawResponse:
+ from .resources.check_deposits import CheckDepositsResourceWithRawResponse
+
+ return CheckDepositsResourceWithRawResponse(self._client.check_deposits)
+
+ @cached_property
+ def lockboxes(self) -> LockboxesResourceWithRawResponse:
+ from .resources.lockboxes import LockboxesResourceWithRawResponse
+
+ return LockboxesResourceWithRawResponse(self._client.lockboxes)
+
+ @cached_property
+ def inbound_mail_items(self) -> InboundMailItemsResourceWithRawResponse:
+ from .resources.inbound_mail_items import InboundMailItemsResourceWithRawResponse
+
+ return InboundMailItemsResourceWithRawResponse(self._client.inbound_mail_items)
+
+ @cached_property
+ def routing_numbers(self) -> RoutingNumbersResourceWithRawResponse:
+ from .resources.routing_numbers import RoutingNumbersResourceWithRawResponse
+
+ return RoutingNumbersResourceWithRawResponse(self._client.routing_numbers)
+
+ @cached_property
+ def external_accounts(self) -> ExternalAccountsResourceWithRawResponse:
+ from .resources.external_accounts import ExternalAccountsResourceWithRawResponse
+
+ return ExternalAccountsResourceWithRawResponse(self._client.external_accounts)
+
+ @cached_property
+ def entities(self) -> EntitiesResourceWithRawResponse:
+ from .resources.entities import EntitiesResourceWithRawResponse
+
+ return EntitiesResourceWithRawResponse(self._client.entities)
+
+ @cached_property
+ def supplemental_documents(self) -> SupplementalDocumentsResourceWithRawResponse:
+ from .resources.supplemental_documents import SupplementalDocumentsResourceWithRawResponse
+
+ return SupplementalDocumentsResourceWithRawResponse(self._client.supplemental_documents)
+
+ @cached_property
+ def programs(self) -> ProgramsResourceWithRawResponse:
+ from .resources.programs import ProgramsResourceWithRawResponse
+
+ return ProgramsResourceWithRawResponse(self._client.programs)
+
+ @cached_property
+ def account_statements(self) -> AccountStatementsResourceWithRawResponse:
+ from .resources.account_statements import AccountStatementsResourceWithRawResponse
+
+ return AccountStatementsResourceWithRawResponse(self._client.account_statements)
+
+ @cached_property
+ def files(self) -> FilesResourceWithRawResponse:
+ from .resources.files import FilesResourceWithRawResponse
+
+ return FilesResourceWithRawResponse(self._client.files)
+
+ @cached_property
+ def file_links(self) -> FileLinksResourceWithRawResponse:
+ from .resources.file_links import FileLinksResourceWithRawResponse
+
+ return FileLinksResourceWithRawResponse(self._client.file_links)
+
+ @cached_property
+ def exports(self) -> ExportsResourceWithRawResponse:
+ from .resources.exports import ExportsResourceWithRawResponse
+
+ return ExportsResourceWithRawResponse(self._client.exports)
+
+ @cached_property
+ def events(self) -> EventsResourceWithRawResponse:
+ from .resources.events import EventsResourceWithRawResponse
+
+ return EventsResourceWithRawResponse(self._client.events)
+
+ @cached_property
+ def event_subscriptions(self) -> EventSubscriptionsResourceWithRawResponse:
+ from .resources.event_subscriptions import EventSubscriptionsResourceWithRawResponse
+
+ return EventSubscriptionsResourceWithRawResponse(self._client.event_subscriptions)
+
+ @cached_property
+ def real_time_decisions(self) -> RealTimeDecisionsResourceWithRawResponse:
+ from .resources.real_time_decisions import RealTimeDecisionsResourceWithRawResponse
+
+ return RealTimeDecisionsResourceWithRawResponse(self._client.real_time_decisions)
+
+ @cached_property
+ def bookkeeping_accounts(self) -> BookkeepingAccountsResourceWithRawResponse:
+ from .resources.bookkeeping_accounts import BookkeepingAccountsResourceWithRawResponse
+
+ return BookkeepingAccountsResourceWithRawResponse(self._client.bookkeeping_accounts)
+
+ @cached_property
+ def bookkeeping_entry_sets(self) -> BookkeepingEntrySetsResourceWithRawResponse:
+ from .resources.bookkeeping_entry_sets import BookkeepingEntrySetsResourceWithRawResponse
+
+ return BookkeepingEntrySetsResourceWithRawResponse(self._client.bookkeeping_entry_sets)
+
+ @cached_property
+ def bookkeeping_entries(self) -> BookkeepingEntriesResourceWithRawResponse:
+ from .resources.bookkeeping_entries import BookkeepingEntriesResourceWithRawResponse
+
+ return BookkeepingEntriesResourceWithRawResponse(self._client.bookkeeping_entries)
+
+ @cached_property
+ def groups(self) -> GroupsResourceWithRawResponse:
+ from .resources.groups import GroupsResourceWithRawResponse
+
+ return GroupsResourceWithRawResponse(self._client.groups)
+
+ @cached_property
+ def oauth_applications(self) -> OAuthApplicationsResourceWithRawResponse:
+ from .resources.oauth_applications import OAuthApplicationsResourceWithRawResponse
+
+ return OAuthApplicationsResourceWithRawResponse(self._client.oauth_applications)
+
+ @cached_property
+ def oauth_connections(self) -> OAuthConnectionsResourceWithRawResponse:
+ from .resources.oauth_connections import OAuthConnectionsResourceWithRawResponse
+
+ return OAuthConnectionsResourceWithRawResponse(self._client.oauth_connections)
+
+ @cached_property
+ def oauth_tokens(self) -> OAuthTokensResourceWithRawResponse:
+ from .resources.oauth_tokens import OAuthTokensResourceWithRawResponse
+
+ return OAuthTokensResourceWithRawResponse(self._client.oauth_tokens)
+
+ @cached_property
+ def intrafi_account_enrollments(
+ self,
+ ) -> IntrafiAccountEnrollmentsResourceWithRawResponse:
+ from .resources.intrafi_account_enrollments import IntrafiAccountEnrollmentsResourceWithRawResponse
+
+ return IntrafiAccountEnrollmentsResourceWithRawResponse(self._client.intrafi_account_enrollments)
+
+ @cached_property
+ def intrafi_balances(self) -> IntrafiBalancesResourceWithRawResponse:
+ from .resources.intrafi_balances import IntrafiBalancesResourceWithRawResponse
+
+ return IntrafiBalancesResourceWithRawResponse(self._client.intrafi_balances)
+
+ @cached_property
+ def intrafi_exclusions(self) -> IntrafiExclusionsResourceWithRawResponse:
+ from .resources.intrafi_exclusions import IntrafiExclusionsResourceWithRawResponse
+
+ return IntrafiExclusionsResourceWithRawResponse(self._client.intrafi_exclusions)
+
+ @cached_property
+ def card_tokens(self) -> CardTokensResourceWithRawResponse:
+ from .resources.card_tokens import CardTokensResourceWithRawResponse
+
+ return CardTokensResourceWithRawResponse(self._client.card_tokens)
+
+ @cached_property
+ def card_push_transfers(self) -> CardPushTransfersResourceWithRawResponse:
+ from .resources.card_push_transfers import CardPushTransfersResourceWithRawResponse
+
+ return CardPushTransfersResourceWithRawResponse(self._client.card_push_transfers)
+
+ @cached_property
+ def card_validations(self) -> CardValidationsResourceWithRawResponse:
+ from .resources.card_validations import CardValidationsResourceWithRawResponse
+
+ return CardValidationsResourceWithRawResponse(self._client.card_validations)
+
+ @cached_property
+ def simulations(self) -> SimulationsResourceWithRawResponse:
+ from .resources.simulations import SimulationsResourceWithRawResponse
+
+ return SimulationsResourceWithRawResponse(self._client.simulations)
+
+
+class AsyncIncreaseWithRawResponse:
+ _client: AsyncIncrease
+
+ def __init__(self, client: AsyncIncrease) -> None:
+ self._client = client
+
+ @cached_property
+ def accounts(self) -> AsyncAccountsResourceWithRawResponse:
+ from .resources.accounts import AsyncAccountsResourceWithRawResponse
+
+ return AsyncAccountsResourceWithRawResponse(self._client.accounts)
+
+ @cached_property
+ def account_numbers(self) -> AsyncAccountNumbersResourceWithRawResponse:
+ from .resources.account_numbers import AsyncAccountNumbersResourceWithRawResponse
+
+ return AsyncAccountNumbersResourceWithRawResponse(self._client.account_numbers)
+
+ @cached_property
+ def account_transfers(self) -> AsyncAccountTransfersResourceWithRawResponse:
+ from .resources.account_transfers import AsyncAccountTransfersResourceWithRawResponse
+
+ return AsyncAccountTransfersResourceWithRawResponse(self._client.account_transfers)
+
+ @cached_property
+ def cards(self) -> AsyncCardsResourceWithRawResponse:
+ from .resources.cards import AsyncCardsResourceWithRawResponse
+
+ return AsyncCardsResourceWithRawResponse(self._client.cards)
+
+ @cached_property
+ def card_payments(self) -> AsyncCardPaymentsResourceWithRawResponse:
+ from .resources.card_payments import AsyncCardPaymentsResourceWithRawResponse
+
+ return AsyncCardPaymentsResourceWithRawResponse(self._client.card_payments)
+
+ @cached_property
+ def card_purchase_supplements(
+ self,
+ ) -> AsyncCardPurchaseSupplementsResourceWithRawResponse:
+ from .resources.card_purchase_supplements import AsyncCardPurchaseSupplementsResourceWithRawResponse
+
+ return AsyncCardPurchaseSupplementsResourceWithRawResponse(self._client.card_purchase_supplements)
+
+ @cached_property
+ def card_disputes(self) -> AsyncCardDisputesResourceWithRawResponse:
+ from .resources.card_disputes import AsyncCardDisputesResourceWithRawResponse
+
+ return AsyncCardDisputesResourceWithRawResponse(self._client.card_disputes)
+
+ @cached_property
+ def physical_cards(self) -> AsyncPhysicalCardsResourceWithRawResponse:
+ from .resources.physical_cards import AsyncPhysicalCardsResourceWithRawResponse
+
+ return AsyncPhysicalCardsResourceWithRawResponse(self._client.physical_cards)
+
+ @cached_property
+ def digital_card_profiles(self) -> AsyncDigitalCardProfilesResourceWithRawResponse:
+ from .resources.digital_card_profiles import AsyncDigitalCardProfilesResourceWithRawResponse
+
+ return AsyncDigitalCardProfilesResourceWithRawResponse(self._client.digital_card_profiles)
+
+ @cached_property
+ def physical_card_profiles(self) -> AsyncPhysicalCardProfilesResourceWithRawResponse:
+ from .resources.physical_card_profiles import AsyncPhysicalCardProfilesResourceWithRawResponse
+
+ return AsyncPhysicalCardProfilesResourceWithRawResponse(self._client.physical_card_profiles)
+
+ @cached_property
+ def digital_wallet_tokens(self) -> AsyncDigitalWalletTokensResourceWithRawResponse:
+ from .resources.digital_wallet_tokens import AsyncDigitalWalletTokensResourceWithRawResponse
+
+ return AsyncDigitalWalletTokensResourceWithRawResponse(self._client.digital_wallet_tokens)
+
+ @cached_property
+ def transactions(self) -> AsyncTransactionsResourceWithRawResponse:
+ from .resources.transactions import AsyncTransactionsResourceWithRawResponse
+
+ return AsyncTransactionsResourceWithRawResponse(self._client.transactions)
+
+ @cached_property
+ def pending_transactions(self) -> AsyncPendingTransactionsResourceWithRawResponse:
+ from .resources.pending_transactions import AsyncPendingTransactionsResourceWithRawResponse
+
+ return AsyncPendingTransactionsResourceWithRawResponse(self._client.pending_transactions)
+
+ @cached_property
+ def declined_transactions(self) -> AsyncDeclinedTransactionsResourceWithRawResponse:
+ from .resources.declined_transactions import AsyncDeclinedTransactionsResourceWithRawResponse
+
+ return AsyncDeclinedTransactionsResourceWithRawResponse(self._client.declined_transactions)
+
+ @cached_property
+ def ach_transfers(self) -> AsyncACHTransfersResourceWithRawResponse:
+ from .resources.ach_transfers import AsyncACHTransfersResourceWithRawResponse
+
+ return AsyncACHTransfersResourceWithRawResponse(self._client.ach_transfers)
+
+ @cached_property
+ def ach_prenotifications(self) -> AsyncACHPrenotificationsResourceWithRawResponse:
+ from .resources.ach_prenotifications import AsyncACHPrenotificationsResourceWithRawResponse
+
+ return AsyncACHPrenotificationsResourceWithRawResponse(self._client.ach_prenotifications)
+
+ @cached_property
+ def inbound_ach_transfers(self) -> AsyncInboundACHTransfersResourceWithRawResponse:
+ from .resources.inbound_ach_transfers import AsyncInboundACHTransfersResourceWithRawResponse
+
+ return AsyncInboundACHTransfersResourceWithRawResponse(self._client.inbound_ach_transfers)
+
+ @cached_property
+ def wire_transfers(self) -> AsyncWireTransfersResourceWithRawResponse:
+ from .resources.wire_transfers import AsyncWireTransfersResourceWithRawResponse
+
+ return AsyncWireTransfersResourceWithRawResponse(self._client.wire_transfers)
+
+ @cached_property
+ def inbound_wire_transfers(self) -> AsyncInboundWireTransfersResourceWithRawResponse:
+ from .resources.inbound_wire_transfers import AsyncInboundWireTransfersResourceWithRawResponse
+
+ return AsyncInboundWireTransfersResourceWithRawResponse(self._client.inbound_wire_transfers)
+
+ @cached_property
+ def wire_drawdown_requests(self) -> AsyncWireDrawdownRequestsResourceWithRawResponse:
+ from .resources.wire_drawdown_requests import AsyncWireDrawdownRequestsResourceWithRawResponse
+
+ return AsyncWireDrawdownRequestsResourceWithRawResponse(self._client.wire_drawdown_requests)
+
+ @cached_property
+ def inbound_wire_drawdown_requests(
+ self,
+ ) -> AsyncInboundWireDrawdownRequestsResourceWithRawResponse:
+ from .resources.inbound_wire_drawdown_requests import AsyncInboundWireDrawdownRequestsResourceWithRawResponse
+
+ return AsyncInboundWireDrawdownRequestsResourceWithRawResponse(self._client.inbound_wire_drawdown_requests)
+
+ @cached_property
+ def check_transfers(self) -> AsyncCheckTransfersResourceWithRawResponse:
+ from .resources.check_transfers import AsyncCheckTransfersResourceWithRawResponse
+
+ return AsyncCheckTransfersResourceWithRawResponse(self._client.check_transfers)
+
+ @cached_property
+ def inbound_check_deposits(self) -> AsyncInboundCheckDepositsResourceWithRawResponse:
+ from .resources.inbound_check_deposits import AsyncInboundCheckDepositsResourceWithRawResponse
+
+ return AsyncInboundCheckDepositsResourceWithRawResponse(self._client.inbound_check_deposits)
+
+ @cached_property
+ def real_time_payments_transfers(
+ self,
+ ) -> AsyncRealTimePaymentsTransfersResourceWithRawResponse:
+ from .resources.real_time_payments_transfers import AsyncRealTimePaymentsTransfersResourceWithRawResponse
+
+ return AsyncRealTimePaymentsTransfersResourceWithRawResponse(self._client.real_time_payments_transfers)
+
+ @cached_property
+ def inbound_real_time_payments_transfers(
+ self,
+ ) -> AsyncInboundRealTimePaymentsTransfersResourceWithRawResponse:
+ from .resources.inbound_real_time_payments_transfers import (
+ AsyncInboundRealTimePaymentsTransfersResourceWithRawResponse,
)
- self.oauth_tokens = oauth_tokens.OAuthTokensResourceWithStreamingResponse(client.oauth_tokens)
- self.intrafi_account_enrollments = (
- intrafi_account_enrollments.IntrafiAccountEnrollmentsResourceWithStreamingResponse(
- client.intrafi_account_enrollments
- )
+
+ return AsyncInboundRealTimePaymentsTransfersResourceWithRawResponse(
+ self._client.inbound_real_time_payments_transfers
)
- self.intrafi_balances = intrafi_balances.IntrafiBalancesResourceWithStreamingResponse(client.intrafi_balances)
- self.intrafi_exclusions = intrafi_exclusions.IntrafiExclusionsResourceWithStreamingResponse(
- client.intrafi_exclusions
+
+ @cached_property
+ def fednow_transfers(self) -> AsyncFednowTransfersResourceWithRawResponse:
+ from .resources.fednow_transfers import AsyncFednowTransfersResourceWithRawResponse
+
+ return AsyncFednowTransfersResourceWithRawResponse(self._client.fednow_transfers)
+
+ @cached_property
+ def inbound_fednow_transfers(self) -> AsyncInboundFednowTransfersResourceWithRawResponse:
+ from .resources.inbound_fednow_transfers import AsyncInboundFednowTransfersResourceWithRawResponse
+
+ return AsyncInboundFednowTransfersResourceWithRawResponse(self._client.inbound_fednow_transfers)
+
+ @cached_property
+ def check_deposits(self) -> AsyncCheckDepositsResourceWithRawResponse:
+ from .resources.check_deposits import AsyncCheckDepositsResourceWithRawResponse
+
+ return AsyncCheckDepositsResourceWithRawResponse(self._client.check_deposits)
+
+ @cached_property
+ def lockboxes(self) -> AsyncLockboxesResourceWithRawResponse:
+ from .resources.lockboxes import AsyncLockboxesResourceWithRawResponse
+
+ return AsyncLockboxesResourceWithRawResponse(self._client.lockboxes)
+
+ @cached_property
+ def inbound_mail_items(self) -> AsyncInboundMailItemsResourceWithRawResponse:
+ from .resources.inbound_mail_items import AsyncInboundMailItemsResourceWithRawResponse
+
+ return AsyncInboundMailItemsResourceWithRawResponse(self._client.inbound_mail_items)
+
+ @cached_property
+ def routing_numbers(self) -> AsyncRoutingNumbersResourceWithRawResponse:
+ from .resources.routing_numbers import AsyncRoutingNumbersResourceWithRawResponse
+
+ return AsyncRoutingNumbersResourceWithRawResponse(self._client.routing_numbers)
+
+ @cached_property
+ def external_accounts(self) -> AsyncExternalAccountsResourceWithRawResponse:
+ from .resources.external_accounts import AsyncExternalAccountsResourceWithRawResponse
+
+ return AsyncExternalAccountsResourceWithRawResponse(self._client.external_accounts)
+
+ @cached_property
+ def entities(self) -> AsyncEntitiesResourceWithRawResponse:
+ from .resources.entities import AsyncEntitiesResourceWithRawResponse
+
+ return AsyncEntitiesResourceWithRawResponse(self._client.entities)
+
+ @cached_property
+ def supplemental_documents(self) -> AsyncSupplementalDocumentsResourceWithRawResponse:
+ from .resources.supplemental_documents import AsyncSupplementalDocumentsResourceWithRawResponse
+
+ return AsyncSupplementalDocumentsResourceWithRawResponse(self._client.supplemental_documents)
+
+ @cached_property
+ def programs(self) -> AsyncProgramsResourceWithRawResponse:
+ from .resources.programs import AsyncProgramsResourceWithRawResponse
+
+ return AsyncProgramsResourceWithRawResponse(self._client.programs)
+
+ @cached_property
+ def account_statements(self) -> AsyncAccountStatementsResourceWithRawResponse:
+ from .resources.account_statements import AsyncAccountStatementsResourceWithRawResponse
+
+ return AsyncAccountStatementsResourceWithRawResponse(self._client.account_statements)
+
+ @cached_property
+ def files(self) -> AsyncFilesResourceWithRawResponse:
+ from .resources.files import AsyncFilesResourceWithRawResponse
+
+ return AsyncFilesResourceWithRawResponse(self._client.files)
+
+ @cached_property
+ def file_links(self) -> AsyncFileLinksResourceWithRawResponse:
+ from .resources.file_links import AsyncFileLinksResourceWithRawResponse
+
+ return AsyncFileLinksResourceWithRawResponse(self._client.file_links)
+
+ @cached_property
+ def exports(self) -> AsyncExportsResourceWithRawResponse:
+ from .resources.exports import AsyncExportsResourceWithRawResponse
+
+ return AsyncExportsResourceWithRawResponse(self._client.exports)
+
+ @cached_property
+ def events(self) -> AsyncEventsResourceWithRawResponse:
+ from .resources.events import AsyncEventsResourceWithRawResponse
+
+ return AsyncEventsResourceWithRawResponse(self._client.events)
+
+ @cached_property
+ def event_subscriptions(self) -> AsyncEventSubscriptionsResourceWithRawResponse:
+ from .resources.event_subscriptions import AsyncEventSubscriptionsResourceWithRawResponse
+
+ return AsyncEventSubscriptionsResourceWithRawResponse(self._client.event_subscriptions)
+
+ @cached_property
+ def real_time_decisions(self) -> AsyncRealTimeDecisionsResourceWithRawResponse:
+ from .resources.real_time_decisions import AsyncRealTimeDecisionsResourceWithRawResponse
+
+ return AsyncRealTimeDecisionsResourceWithRawResponse(self._client.real_time_decisions)
+
+ @cached_property
+ def bookkeeping_accounts(self) -> AsyncBookkeepingAccountsResourceWithRawResponse:
+ from .resources.bookkeeping_accounts import AsyncBookkeepingAccountsResourceWithRawResponse
+
+ return AsyncBookkeepingAccountsResourceWithRawResponse(self._client.bookkeeping_accounts)
+
+ @cached_property
+ def bookkeeping_entry_sets(self) -> AsyncBookkeepingEntrySetsResourceWithRawResponse:
+ from .resources.bookkeeping_entry_sets import AsyncBookkeepingEntrySetsResourceWithRawResponse
+
+ return AsyncBookkeepingEntrySetsResourceWithRawResponse(self._client.bookkeeping_entry_sets)
+
+ @cached_property
+ def bookkeeping_entries(self) -> AsyncBookkeepingEntriesResourceWithRawResponse:
+ from .resources.bookkeeping_entries import AsyncBookkeepingEntriesResourceWithRawResponse
+
+ return AsyncBookkeepingEntriesResourceWithRawResponse(self._client.bookkeeping_entries)
+
+ @cached_property
+ def groups(self) -> AsyncGroupsResourceWithRawResponse:
+ from .resources.groups import AsyncGroupsResourceWithRawResponse
+
+ return AsyncGroupsResourceWithRawResponse(self._client.groups)
+
+ @cached_property
+ def oauth_applications(self) -> AsyncOAuthApplicationsResourceWithRawResponse:
+ from .resources.oauth_applications import AsyncOAuthApplicationsResourceWithRawResponse
+
+ return AsyncOAuthApplicationsResourceWithRawResponse(self._client.oauth_applications)
+
+ @cached_property
+ def oauth_connections(self) -> AsyncOAuthConnectionsResourceWithRawResponse:
+ from .resources.oauth_connections import AsyncOAuthConnectionsResourceWithRawResponse
+
+ return AsyncOAuthConnectionsResourceWithRawResponse(self._client.oauth_connections)
+
+ @cached_property
+ def oauth_tokens(self) -> AsyncOAuthTokensResourceWithRawResponse:
+ from .resources.oauth_tokens import AsyncOAuthTokensResourceWithRawResponse
+
+ return AsyncOAuthTokensResourceWithRawResponse(self._client.oauth_tokens)
+
+ @cached_property
+ def intrafi_account_enrollments(
+ self,
+ ) -> AsyncIntrafiAccountEnrollmentsResourceWithRawResponse:
+ from .resources.intrafi_account_enrollments import AsyncIntrafiAccountEnrollmentsResourceWithRawResponse
+
+ return AsyncIntrafiAccountEnrollmentsResourceWithRawResponse(self._client.intrafi_account_enrollments)
+
+ @cached_property
+ def intrafi_balances(self) -> AsyncIntrafiBalancesResourceWithRawResponse:
+ from .resources.intrafi_balances import AsyncIntrafiBalancesResourceWithRawResponse
+
+ return AsyncIntrafiBalancesResourceWithRawResponse(self._client.intrafi_balances)
+
+ @cached_property
+ def intrafi_exclusions(self) -> AsyncIntrafiExclusionsResourceWithRawResponse:
+ from .resources.intrafi_exclusions import AsyncIntrafiExclusionsResourceWithRawResponse
+
+ return AsyncIntrafiExclusionsResourceWithRawResponse(self._client.intrafi_exclusions)
+
+ @cached_property
+ def card_tokens(self) -> AsyncCardTokensResourceWithRawResponse:
+ from .resources.card_tokens import AsyncCardTokensResourceWithRawResponse
+
+ return AsyncCardTokensResourceWithRawResponse(self._client.card_tokens)
+
+ @cached_property
+ def card_push_transfers(self) -> AsyncCardPushTransfersResourceWithRawResponse:
+ from .resources.card_push_transfers import AsyncCardPushTransfersResourceWithRawResponse
+
+ return AsyncCardPushTransfersResourceWithRawResponse(self._client.card_push_transfers)
+
+ @cached_property
+ def card_validations(self) -> AsyncCardValidationsResourceWithRawResponse:
+ from .resources.card_validations import AsyncCardValidationsResourceWithRawResponse
+
+ return AsyncCardValidationsResourceWithRawResponse(self._client.card_validations)
+
+ @cached_property
+ def simulations(self) -> AsyncSimulationsResourceWithRawResponse:
+ from .resources.simulations import AsyncSimulationsResourceWithRawResponse
+
+ return AsyncSimulationsResourceWithRawResponse(self._client.simulations)
+
+
+class IncreaseWithStreamedResponse:
+ _client: Increase
+
+ def __init__(self, client: Increase) -> None:
+ self._client = client
+
+ @cached_property
+ def accounts(self) -> AccountsResourceWithStreamingResponse:
+ from .resources.accounts import AccountsResourceWithStreamingResponse
+
+ return AccountsResourceWithStreamingResponse(self._client.accounts)
+
+ @cached_property
+ def account_numbers(self) -> AccountNumbersResourceWithStreamingResponse:
+ from .resources.account_numbers import AccountNumbersResourceWithStreamingResponse
+
+ return AccountNumbersResourceWithStreamingResponse(self._client.account_numbers)
+
+ @cached_property
+ def account_transfers(self) -> AccountTransfersResourceWithStreamingResponse:
+ from .resources.account_transfers import AccountTransfersResourceWithStreamingResponse
+
+ return AccountTransfersResourceWithStreamingResponse(self._client.account_transfers)
+
+ @cached_property
+ def cards(self) -> CardsResourceWithStreamingResponse:
+ from .resources.cards import CardsResourceWithStreamingResponse
+
+ return CardsResourceWithStreamingResponse(self._client.cards)
+
+ @cached_property
+ def card_payments(self) -> CardPaymentsResourceWithStreamingResponse:
+ from .resources.card_payments import CardPaymentsResourceWithStreamingResponse
+
+ return CardPaymentsResourceWithStreamingResponse(self._client.card_payments)
+
+ @cached_property
+ def card_purchase_supplements(
+ self,
+ ) -> CardPurchaseSupplementsResourceWithStreamingResponse:
+ from .resources.card_purchase_supplements import CardPurchaseSupplementsResourceWithStreamingResponse
+
+ return CardPurchaseSupplementsResourceWithStreamingResponse(self._client.card_purchase_supplements)
+
+ @cached_property
+ def card_disputes(self) -> CardDisputesResourceWithStreamingResponse:
+ from .resources.card_disputes import CardDisputesResourceWithStreamingResponse
+
+ return CardDisputesResourceWithStreamingResponse(self._client.card_disputes)
+
+ @cached_property
+ def physical_cards(self) -> PhysicalCardsResourceWithStreamingResponse:
+ from .resources.physical_cards import PhysicalCardsResourceWithStreamingResponse
+
+ return PhysicalCardsResourceWithStreamingResponse(self._client.physical_cards)
+
+ @cached_property
+ def digital_card_profiles(self) -> DigitalCardProfilesResourceWithStreamingResponse:
+ from .resources.digital_card_profiles import DigitalCardProfilesResourceWithStreamingResponse
+
+ return DigitalCardProfilesResourceWithStreamingResponse(self._client.digital_card_profiles)
+
+ @cached_property
+ def physical_card_profiles(self) -> PhysicalCardProfilesResourceWithStreamingResponse:
+ from .resources.physical_card_profiles import PhysicalCardProfilesResourceWithStreamingResponse
+
+ return PhysicalCardProfilesResourceWithStreamingResponse(self._client.physical_card_profiles)
+
+ @cached_property
+ def digital_wallet_tokens(self) -> DigitalWalletTokensResourceWithStreamingResponse:
+ from .resources.digital_wallet_tokens import DigitalWalletTokensResourceWithStreamingResponse
+
+ return DigitalWalletTokensResourceWithStreamingResponse(self._client.digital_wallet_tokens)
+
+ @cached_property
+ def transactions(self) -> TransactionsResourceWithStreamingResponse:
+ from .resources.transactions import TransactionsResourceWithStreamingResponse
+
+ return TransactionsResourceWithStreamingResponse(self._client.transactions)
+
+ @cached_property
+ def pending_transactions(self) -> PendingTransactionsResourceWithStreamingResponse:
+ from .resources.pending_transactions import PendingTransactionsResourceWithStreamingResponse
+
+ return PendingTransactionsResourceWithStreamingResponse(self._client.pending_transactions)
+
+ @cached_property
+ def declined_transactions(self) -> DeclinedTransactionsResourceWithStreamingResponse:
+ from .resources.declined_transactions import DeclinedTransactionsResourceWithStreamingResponse
+
+ return DeclinedTransactionsResourceWithStreamingResponse(self._client.declined_transactions)
+
+ @cached_property
+ def ach_transfers(self) -> ACHTransfersResourceWithStreamingResponse:
+ from .resources.ach_transfers import ACHTransfersResourceWithStreamingResponse
+
+ return ACHTransfersResourceWithStreamingResponse(self._client.ach_transfers)
+
+ @cached_property
+ def ach_prenotifications(self) -> ACHPrenotificationsResourceWithStreamingResponse:
+ from .resources.ach_prenotifications import ACHPrenotificationsResourceWithStreamingResponse
+
+ return ACHPrenotificationsResourceWithStreamingResponse(self._client.ach_prenotifications)
+
+ @cached_property
+ def inbound_ach_transfers(self) -> InboundACHTransfersResourceWithStreamingResponse:
+ from .resources.inbound_ach_transfers import InboundACHTransfersResourceWithStreamingResponse
+
+ return InboundACHTransfersResourceWithStreamingResponse(self._client.inbound_ach_transfers)
+
+ @cached_property
+ def wire_transfers(self) -> WireTransfersResourceWithStreamingResponse:
+ from .resources.wire_transfers import WireTransfersResourceWithStreamingResponse
+
+ return WireTransfersResourceWithStreamingResponse(self._client.wire_transfers)
+
+ @cached_property
+ def inbound_wire_transfers(self) -> InboundWireTransfersResourceWithStreamingResponse:
+ from .resources.inbound_wire_transfers import InboundWireTransfersResourceWithStreamingResponse
+
+ return InboundWireTransfersResourceWithStreamingResponse(self._client.inbound_wire_transfers)
+
+ @cached_property
+ def wire_drawdown_requests(self) -> WireDrawdownRequestsResourceWithStreamingResponse:
+ from .resources.wire_drawdown_requests import WireDrawdownRequestsResourceWithStreamingResponse
+
+ return WireDrawdownRequestsResourceWithStreamingResponse(self._client.wire_drawdown_requests)
+
+ @cached_property
+ def inbound_wire_drawdown_requests(
+ self,
+ ) -> InboundWireDrawdownRequestsResourceWithStreamingResponse:
+ from .resources.inbound_wire_drawdown_requests import InboundWireDrawdownRequestsResourceWithStreamingResponse
+
+ return InboundWireDrawdownRequestsResourceWithStreamingResponse(self._client.inbound_wire_drawdown_requests)
+
+ @cached_property
+ def check_transfers(self) -> CheckTransfersResourceWithStreamingResponse:
+ from .resources.check_transfers import CheckTransfersResourceWithStreamingResponse
+
+ return CheckTransfersResourceWithStreamingResponse(self._client.check_transfers)
+
+ @cached_property
+ def inbound_check_deposits(self) -> InboundCheckDepositsResourceWithStreamingResponse:
+ from .resources.inbound_check_deposits import InboundCheckDepositsResourceWithStreamingResponse
+
+ return InboundCheckDepositsResourceWithStreamingResponse(self._client.inbound_check_deposits)
+
+ @cached_property
+ def real_time_payments_transfers(
+ self,
+ ) -> RealTimePaymentsTransfersResourceWithStreamingResponse:
+ from .resources.real_time_payments_transfers import RealTimePaymentsTransfersResourceWithStreamingResponse
+
+ return RealTimePaymentsTransfersResourceWithStreamingResponse(self._client.real_time_payments_transfers)
+
+ @cached_property
+ def inbound_real_time_payments_transfers(
+ self,
+ ) -> InboundRealTimePaymentsTransfersResourceWithStreamingResponse:
+ from .resources.inbound_real_time_payments_transfers import (
+ InboundRealTimePaymentsTransfersResourceWithStreamingResponse,
)
- self.card_tokens = card_tokens.CardTokensResourceWithStreamingResponse(client.card_tokens)
- self.card_push_transfers = card_push_transfers.CardPushTransfersResourceWithStreamingResponse(
- client.card_push_transfers
+
+ return InboundRealTimePaymentsTransfersResourceWithStreamingResponse(
+ self._client.inbound_real_time_payments_transfers
)
- self.card_validations = card_validations.CardValidationsResourceWithStreamingResponse(client.card_validations)
- self.simulations = simulations.SimulationsResourceWithStreamingResponse(client.simulations)
+
+ @cached_property
+ def fednow_transfers(self) -> FednowTransfersResourceWithStreamingResponse:
+ from .resources.fednow_transfers import FednowTransfersResourceWithStreamingResponse
+
+ return FednowTransfersResourceWithStreamingResponse(self._client.fednow_transfers)
+
+ @cached_property
+ def inbound_fednow_transfers(self) -> InboundFednowTransfersResourceWithStreamingResponse:
+ from .resources.inbound_fednow_transfers import InboundFednowTransfersResourceWithStreamingResponse
+
+ return InboundFednowTransfersResourceWithStreamingResponse(self._client.inbound_fednow_transfers)
+
+ @cached_property
+ def check_deposits(self) -> CheckDepositsResourceWithStreamingResponse:
+ from .resources.check_deposits import CheckDepositsResourceWithStreamingResponse
+
+ return CheckDepositsResourceWithStreamingResponse(self._client.check_deposits)
+
+ @cached_property
+ def lockboxes(self) -> LockboxesResourceWithStreamingResponse:
+ from .resources.lockboxes import LockboxesResourceWithStreamingResponse
+
+ return LockboxesResourceWithStreamingResponse(self._client.lockboxes)
+
+ @cached_property
+ def inbound_mail_items(self) -> InboundMailItemsResourceWithStreamingResponse:
+ from .resources.inbound_mail_items import InboundMailItemsResourceWithStreamingResponse
+
+ return InboundMailItemsResourceWithStreamingResponse(self._client.inbound_mail_items)
+
+ @cached_property
+ def routing_numbers(self) -> RoutingNumbersResourceWithStreamingResponse:
+ from .resources.routing_numbers import RoutingNumbersResourceWithStreamingResponse
+
+ return RoutingNumbersResourceWithStreamingResponse(self._client.routing_numbers)
+
+ @cached_property
+ def external_accounts(self) -> ExternalAccountsResourceWithStreamingResponse:
+ from .resources.external_accounts import ExternalAccountsResourceWithStreamingResponse
+
+ return ExternalAccountsResourceWithStreamingResponse(self._client.external_accounts)
+
+ @cached_property
+ def entities(self) -> EntitiesResourceWithStreamingResponse:
+ from .resources.entities import EntitiesResourceWithStreamingResponse
+
+ return EntitiesResourceWithStreamingResponse(self._client.entities)
+
+ @cached_property
+ def supplemental_documents(self) -> SupplementalDocumentsResourceWithStreamingResponse:
+ from .resources.supplemental_documents import SupplementalDocumentsResourceWithStreamingResponse
+
+ return SupplementalDocumentsResourceWithStreamingResponse(self._client.supplemental_documents)
+
+ @cached_property
+ def programs(self) -> ProgramsResourceWithStreamingResponse:
+ from .resources.programs import ProgramsResourceWithStreamingResponse
+
+ return ProgramsResourceWithStreamingResponse(self._client.programs)
+
+ @cached_property
+ def account_statements(self) -> AccountStatementsResourceWithStreamingResponse:
+ from .resources.account_statements import AccountStatementsResourceWithStreamingResponse
+
+ return AccountStatementsResourceWithStreamingResponse(self._client.account_statements)
+
+ @cached_property
+ def files(self) -> FilesResourceWithStreamingResponse:
+ from .resources.files import FilesResourceWithStreamingResponse
+
+ return FilesResourceWithStreamingResponse(self._client.files)
+
+ @cached_property
+ def file_links(self) -> FileLinksResourceWithStreamingResponse:
+ from .resources.file_links import FileLinksResourceWithStreamingResponse
+
+ return FileLinksResourceWithStreamingResponse(self._client.file_links)
+
+ @cached_property
+ def exports(self) -> ExportsResourceWithStreamingResponse:
+ from .resources.exports import ExportsResourceWithStreamingResponse
+
+ return ExportsResourceWithStreamingResponse(self._client.exports)
+
+ @cached_property
+ def events(self) -> EventsResourceWithStreamingResponse:
+ from .resources.events import EventsResourceWithStreamingResponse
+
+ return EventsResourceWithStreamingResponse(self._client.events)
+
+ @cached_property
+ def event_subscriptions(self) -> EventSubscriptionsResourceWithStreamingResponse:
+ from .resources.event_subscriptions import EventSubscriptionsResourceWithStreamingResponse
+
+ return EventSubscriptionsResourceWithStreamingResponse(self._client.event_subscriptions)
+
+ @cached_property
+ def real_time_decisions(self) -> RealTimeDecisionsResourceWithStreamingResponse:
+ from .resources.real_time_decisions import RealTimeDecisionsResourceWithStreamingResponse
+
+ return RealTimeDecisionsResourceWithStreamingResponse(self._client.real_time_decisions)
+
+ @cached_property
+ def bookkeeping_accounts(self) -> BookkeepingAccountsResourceWithStreamingResponse:
+ from .resources.bookkeeping_accounts import BookkeepingAccountsResourceWithStreamingResponse
+
+ return BookkeepingAccountsResourceWithStreamingResponse(self._client.bookkeeping_accounts)
+
+ @cached_property
+ def bookkeeping_entry_sets(self) -> BookkeepingEntrySetsResourceWithStreamingResponse:
+ from .resources.bookkeeping_entry_sets import BookkeepingEntrySetsResourceWithStreamingResponse
+
+ return BookkeepingEntrySetsResourceWithStreamingResponse(self._client.bookkeeping_entry_sets)
+
+ @cached_property
+ def bookkeeping_entries(self) -> BookkeepingEntriesResourceWithStreamingResponse:
+ from .resources.bookkeeping_entries import BookkeepingEntriesResourceWithStreamingResponse
+
+ return BookkeepingEntriesResourceWithStreamingResponse(self._client.bookkeeping_entries)
+
+ @cached_property
+ def groups(self) -> GroupsResourceWithStreamingResponse:
+ from .resources.groups import GroupsResourceWithStreamingResponse
+
+ return GroupsResourceWithStreamingResponse(self._client.groups)
+
+ @cached_property
+ def oauth_applications(self) -> OAuthApplicationsResourceWithStreamingResponse:
+ from .resources.oauth_applications import OAuthApplicationsResourceWithStreamingResponse
+
+ return OAuthApplicationsResourceWithStreamingResponse(self._client.oauth_applications)
+
+ @cached_property
+ def oauth_connections(self) -> OAuthConnectionsResourceWithStreamingResponse:
+ from .resources.oauth_connections import OAuthConnectionsResourceWithStreamingResponse
+
+ return OAuthConnectionsResourceWithStreamingResponse(self._client.oauth_connections)
+
+ @cached_property
+ def oauth_tokens(self) -> OAuthTokensResourceWithStreamingResponse:
+ from .resources.oauth_tokens import OAuthTokensResourceWithStreamingResponse
+
+ return OAuthTokensResourceWithStreamingResponse(self._client.oauth_tokens)
+
+ @cached_property
+ def intrafi_account_enrollments(
+ self,
+ ) -> IntrafiAccountEnrollmentsResourceWithStreamingResponse:
+ from .resources.intrafi_account_enrollments import IntrafiAccountEnrollmentsResourceWithStreamingResponse
+
+ return IntrafiAccountEnrollmentsResourceWithStreamingResponse(self._client.intrafi_account_enrollments)
+
+ @cached_property
+ def intrafi_balances(self) -> IntrafiBalancesResourceWithStreamingResponse:
+ from .resources.intrafi_balances import IntrafiBalancesResourceWithStreamingResponse
+
+ return IntrafiBalancesResourceWithStreamingResponse(self._client.intrafi_balances)
+
+ @cached_property
+ def intrafi_exclusions(self) -> IntrafiExclusionsResourceWithStreamingResponse:
+ from .resources.intrafi_exclusions import IntrafiExclusionsResourceWithStreamingResponse
+
+ return IntrafiExclusionsResourceWithStreamingResponse(self._client.intrafi_exclusions)
+
+ @cached_property
+ def card_tokens(self) -> CardTokensResourceWithStreamingResponse:
+ from .resources.card_tokens import CardTokensResourceWithStreamingResponse
+
+ return CardTokensResourceWithStreamingResponse(self._client.card_tokens)
+
+ @cached_property
+ def card_push_transfers(self) -> CardPushTransfersResourceWithStreamingResponse:
+ from .resources.card_push_transfers import CardPushTransfersResourceWithStreamingResponse
+
+ return CardPushTransfersResourceWithStreamingResponse(self._client.card_push_transfers)
+
+ @cached_property
+ def card_validations(self) -> CardValidationsResourceWithStreamingResponse:
+ from .resources.card_validations import CardValidationsResourceWithStreamingResponse
+
+ return CardValidationsResourceWithStreamingResponse(self._client.card_validations)
+
+ @cached_property
+ def simulations(self) -> SimulationsResourceWithStreamingResponse:
+ from .resources.simulations import SimulationsResourceWithStreamingResponse
+
+ return SimulationsResourceWithStreamingResponse(self._client.simulations)
class AsyncIncreaseWithStreamedResponse:
+ _client: AsyncIncrease
+
def __init__(self, client: AsyncIncrease) -> None:
- self.accounts = accounts.AsyncAccountsResourceWithStreamingResponse(client.accounts)
- self.account_numbers = account_numbers.AsyncAccountNumbersResourceWithStreamingResponse(client.account_numbers)
- self.account_transfers = account_transfers.AsyncAccountTransfersResourceWithStreamingResponse(
- client.account_transfers
- )
- self.cards = cards.AsyncCardsResourceWithStreamingResponse(client.cards)
- self.card_payments = card_payments.AsyncCardPaymentsResourceWithStreamingResponse(client.card_payments)
- self.card_purchase_supplements = (
- card_purchase_supplements.AsyncCardPurchaseSupplementsResourceWithStreamingResponse(
- client.card_purchase_supplements
- )
- )
- self.card_disputes = card_disputes.AsyncCardDisputesResourceWithStreamingResponse(client.card_disputes)
- self.physical_cards = physical_cards.AsyncPhysicalCardsResourceWithStreamingResponse(client.physical_cards)
- self.digital_card_profiles = digital_card_profiles.AsyncDigitalCardProfilesResourceWithStreamingResponse(
- client.digital_card_profiles
- )
- self.physical_card_profiles = physical_card_profiles.AsyncPhysicalCardProfilesResourceWithStreamingResponse(
- client.physical_card_profiles
- )
- self.digital_wallet_tokens = digital_wallet_tokens.AsyncDigitalWalletTokensResourceWithStreamingResponse(
- client.digital_wallet_tokens
- )
- self.transactions = transactions.AsyncTransactionsResourceWithStreamingResponse(client.transactions)
- self.pending_transactions = pending_transactions.AsyncPendingTransactionsResourceWithStreamingResponse(
- client.pending_transactions
- )
- self.declined_transactions = declined_transactions.AsyncDeclinedTransactionsResourceWithStreamingResponse(
- client.declined_transactions
- )
- self.ach_transfers = ach_transfers.AsyncACHTransfersResourceWithStreamingResponse(client.ach_transfers)
- self.ach_prenotifications = ach_prenotifications.AsyncACHPrenotificationsResourceWithStreamingResponse(
- client.ach_prenotifications
- )
- self.inbound_ach_transfers = inbound_ach_transfers.AsyncInboundACHTransfersResourceWithStreamingResponse(
- client.inbound_ach_transfers
- )
- self.wire_transfers = wire_transfers.AsyncWireTransfersResourceWithStreamingResponse(client.wire_transfers)
- self.inbound_wire_transfers = inbound_wire_transfers.AsyncInboundWireTransfersResourceWithStreamingResponse(
- client.inbound_wire_transfers
- )
- self.wire_drawdown_requests = wire_drawdown_requests.AsyncWireDrawdownRequestsResourceWithStreamingResponse(
- client.wire_drawdown_requests
- )
- self.inbound_wire_drawdown_requests = (
- inbound_wire_drawdown_requests.AsyncInboundWireDrawdownRequestsResourceWithStreamingResponse(
- client.inbound_wire_drawdown_requests
- )
- )
- self.check_transfers = check_transfers.AsyncCheckTransfersResourceWithStreamingResponse(client.check_transfers)
- self.inbound_check_deposits = inbound_check_deposits.AsyncInboundCheckDepositsResourceWithStreamingResponse(
- client.inbound_check_deposits
- )
- self.real_time_payments_transfers = (
- real_time_payments_transfers.AsyncRealTimePaymentsTransfersResourceWithStreamingResponse(
- client.real_time_payments_transfers
- )
- )
- self.inbound_real_time_payments_transfers = (
- inbound_real_time_payments_transfers.AsyncInboundRealTimePaymentsTransfersResourceWithStreamingResponse(
- client.inbound_real_time_payments_transfers
- )
- )
- self.fednow_transfers = fednow_transfers.AsyncFednowTransfersResourceWithStreamingResponse(
- client.fednow_transfers
- )
- self.inbound_fednow_transfers = (
- inbound_fednow_transfers.AsyncInboundFednowTransfersResourceWithStreamingResponse(
- client.inbound_fednow_transfers
- )
- )
- self.check_deposits = check_deposits.AsyncCheckDepositsResourceWithStreamingResponse(client.check_deposits)
- self.lockboxes = lockboxes.AsyncLockboxesResourceWithStreamingResponse(client.lockboxes)
- self.inbound_mail_items = inbound_mail_items.AsyncInboundMailItemsResourceWithStreamingResponse(
- client.inbound_mail_items
- )
- self.routing_numbers = routing_numbers.AsyncRoutingNumbersResourceWithStreamingResponse(client.routing_numbers)
- self.external_accounts = external_accounts.AsyncExternalAccountsResourceWithStreamingResponse(
- client.external_accounts
- )
- self.entities = entities.AsyncEntitiesResourceWithStreamingResponse(client.entities)
- self.supplemental_documents = supplemental_documents.AsyncSupplementalDocumentsResourceWithStreamingResponse(
- client.supplemental_documents
- )
- self.programs = programs.AsyncProgramsResourceWithStreamingResponse(client.programs)
- self.account_statements = account_statements.AsyncAccountStatementsResourceWithStreamingResponse(
- client.account_statements
- )
- self.files = files.AsyncFilesResourceWithStreamingResponse(client.files)
- self.file_links = file_links.AsyncFileLinksResourceWithStreamingResponse(client.file_links)
- self.documents = documents.AsyncDocumentsResourceWithStreamingResponse(client.documents)
- self.exports = exports.AsyncExportsResourceWithStreamingResponse(client.exports)
- self.events = events.AsyncEventsResourceWithStreamingResponse(client.events)
- self.event_subscriptions = event_subscriptions.AsyncEventSubscriptionsResourceWithStreamingResponse(
- client.event_subscriptions
- )
- self.real_time_decisions = real_time_decisions.AsyncRealTimeDecisionsResourceWithStreamingResponse(
- client.real_time_decisions
- )
- self.bookkeeping_accounts = bookkeeping_accounts.AsyncBookkeepingAccountsResourceWithStreamingResponse(
- client.bookkeeping_accounts
- )
- self.bookkeeping_entry_sets = bookkeeping_entry_sets.AsyncBookkeepingEntrySetsResourceWithStreamingResponse(
- client.bookkeeping_entry_sets
- )
- self.bookkeeping_entries = bookkeeping_entries.AsyncBookkeepingEntriesResourceWithStreamingResponse(
- client.bookkeeping_entries
- )
- self.groups = groups.AsyncGroupsResourceWithStreamingResponse(client.groups)
- self.oauth_applications = oauth_applications.AsyncOAuthApplicationsResourceWithStreamingResponse(
- client.oauth_applications
- )
- self.oauth_connections = oauth_connections.AsyncOAuthConnectionsResourceWithStreamingResponse(
- client.oauth_connections
- )
- self.oauth_tokens = oauth_tokens.AsyncOAuthTokensResourceWithStreamingResponse(client.oauth_tokens)
- self.intrafi_account_enrollments = (
- intrafi_account_enrollments.AsyncIntrafiAccountEnrollmentsResourceWithStreamingResponse(
- client.intrafi_account_enrollments
- )
- )
- self.intrafi_balances = intrafi_balances.AsyncIntrafiBalancesResourceWithStreamingResponse(
- client.intrafi_balances
+ self._client = client
+
+ @cached_property
+ def accounts(self) -> AsyncAccountsResourceWithStreamingResponse:
+ from .resources.accounts import AsyncAccountsResourceWithStreamingResponse
+
+ return AsyncAccountsResourceWithStreamingResponse(self._client.accounts)
+
+ @cached_property
+ def account_numbers(self) -> AsyncAccountNumbersResourceWithStreamingResponse:
+ from .resources.account_numbers import AsyncAccountNumbersResourceWithStreamingResponse
+
+ return AsyncAccountNumbersResourceWithStreamingResponse(self._client.account_numbers)
+
+ @cached_property
+ def account_transfers(self) -> AsyncAccountTransfersResourceWithStreamingResponse:
+ from .resources.account_transfers import AsyncAccountTransfersResourceWithStreamingResponse
+
+ return AsyncAccountTransfersResourceWithStreamingResponse(self._client.account_transfers)
+
+ @cached_property
+ def cards(self) -> AsyncCardsResourceWithStreamingResponse:
+ from .resources.cards import AsyncCardsResourceWithStreamingResponse
+
+ return AsyncCardsResourceWithStreamingResponse(self._client.cards)
+
+ @cached_property
+ def card_payments(self) -> AsyncCardPaymentsResourceWithStreamingResponse:
+ from .resources.card_payments import AsyncCardPaymentsResourceWithStreamingResponse
+
+ return AsyncCardPaymentsResourceWithStreamingResponse(self._client.card_payments)
+
+ @cached_property
+ def card_purchase_supplements(
+ self,
+ ) -> AsyncCardPurchaseSupplementsResourceWithStreamingResponse:
+ from .resources.card_purchase_supplements import AsyncCardPurchaseSupplementsResourceWithStreamingResponse
+
+ return AsyncCardPurchaseSupplementsResourceWithStreamingResponse(self._client.card_purchase_supplements)
+
+ @cached_property
+ def card_disputes(self) -> AsyncCardDisputesResourceWithStreamingResponse:
+ from .resources.card_disputes import AsyncCardDisputesResourceWithStreamingResponse
+
+ return AsyncCardDisputesResourceWithStreamingResponse(self._client.card_disputes)
+
+ @cached_property
+ def physical_cards(self) -> AsyncPhysicalCardsResourceWithStreamingResponse:
+ from .resources.physical_cards import AsyncPhysicalCardsResourceWithStreamingResponse
+
+ return AsyncPhysicalCardsResourceWithStreamingResponse(self._client.physical_cards)
+
+ @cached_property
+ def digital_card_profiles(self) -> AsyncDigitalCardProfilesResourceWithStreamingResponse:
+ from .resources.digital_card_profiles import AsyncDigitalCardProfilesResourceWithStreamingResponse
+
+ return AsyncDigitalCardProfilesResourceWithStreamingResponse(self._client.digital_card_profiles)
+
+ @cached_property
+ def physical_card_profiles(self) -> AsyncPhysicalCardProfilesResourceWithStreamingResponse:
+ from .resources.physical_card_profiles import AsyncPhysicalCardProfilesResourceWithStreamingResponse
+
+ return AsyncPhysicalCardProfilesResourceWithStreamingResponse(self._client.physical_card_profiles)
+
+ @cached_property
+ def digital_wallet_tokens(self) -> AsyncDigitalWalletTokensResourceWithStreamingResponse:
+ from .resources.digital_wallet_tokens import AsyncDigitalWalletTokensResourceWithStreamingResponse
+
+ return AsyncDigitalWalletTokensResourceWithStreamingResponse(self._client.digital_wallet_tokens)
+
+ @cached_property
+ def transactions(self) -> AsyncTransactionsResourceWithStreamingResponse:
+ from .resources.transactions import AsyncTransactionsResourceWithStreamingResponse
+
+ return AsyncTransactionsResourceWithStreamingResponse(self._client.transactions)
+
+ @cached_property
+ def pending_transactions(self) -> AsyncPendingTransactionsResourceWithStreamingResponse:
+ from .resources.pending_transactions import AsyncPendingTransactionsResourceWithStreamingResponse
+
+ return AsyncPendingTransactionsResourceWithStreamingResponse(self._client.pending_transactions)
+
+ @cached_property
+ def declined_transactions(self) -> AsyncDeclinedTransactionsResourceWithStreamingResponse:
+ from .resources.declined_transactions import AsyncDeclinedTransactionsResourceWithStreamingResponse
+
+ return AsyncDeclinedTransactionsResourceWithStreamingResponse(self._client.declined_transactions)
+
+ @cached_property
+ def ach_transfers(self) -> AsyncACHTransfersResourceWithStreamingResponse:
+ from .resources.ach_transfers import AsyncACHTransfersResourceWithStreamingResponse
+
+ return AsyncACHTransfersResourceWithStreamingResponse(self._client.ach_transfers)
+
+ @cached_property
+ def ach_prenotifications(self) -> AsyncACHPrenotificationsResourceWithStreamingResponse:
+ from .resources.ach_prenotifications import AsyncACHPrenotificationsResourceWithStreamingResponse
+
+ return AsyncACHPrenotificationsResourceWithStreamingResponse(self._client.ach_prenotifications)
+
+ @cached_property
+ def inbound_ach_transfers(self) -> AsyncInboundACHTransfersResourceWithStreamingResponse:
+ from .resources.inbound_ach_transfers import AsyncInboundACHTransfersResourceWithStreamingResponse
+
+ return AsyncInboundACHTransfersResourceWithStreamingResponse(self._client.inbound_ach_transfers)
+
+ @cached_property
+ def wire_transfers(self) -> AsyncWireTransfersResourceWithStreamingResponse:
+ from .resources.wire_transfers import AsyncWireTransfersResourceWithStreamingResponse
+
+ return AsyncWireTransfersResourceWithStreamingResponse(self._client.wire_transfers)
+
+ @cached_property
+ def inbound_wire_transfers(self) -> AsyncInboundWireTransfersResourceWithStreamingResponse:
+ from .resources.inbound_wire_transfers import AsyncInboundWireTransfersResourceWithStreamingResponse
+
+ return AsyncInboundWireTransfersResourceWithStreamingResponse(self._client.inbound_wire_transfers)
+
+ @cached_property
+ def wire_drawdown_requests(self) -> AsyncWireDrawdownRequestsResourceWithStreamingResponse:
+ from .resources.wire_drawdown_requests import AsyncWireDrawdownRequestsResourceWithStreamingResponse
+
+ return AsyncWireDrawdownRequestsResourceWithStreamingResponse(self._client.wire_drawdown_requests)
+
+ @cached_property
+ def inbound_wire_drawdown_requests(
+ self,
+ ) -> AsyncInboundWireDrawdownRequestsResourceWithStreamingResponse:
+ from .resources.inbound_wire_drawdown_requests import (
+ AsyncInboundWireDrawdownRequestsResourceWithStreamingResponse,
)
- self.intrafi_exclusions = intrafi_exclusions.AsyncIntrafiExclusionsResourceWithStreamingResponse(
- client.intrafi_exclusions
+
+ return AsyncInboundWireDrawdownRequestsResourceWithStreamingResponse(
+ self._client.inbound_wire_drawdown_requests
)
- self.card_tokens = card_tokens.AsyncCardTokensResourceWithStreamingResponse(client.card_tokens)
- self.card_push_transfers = card_push_transfers.AsyncCardPushTransfersResourceWithStreamingResponse(
- client.card_push_transfers
+
+ @cached_property
+ def check_transfers(self) -> AsyncCheckTransfersResourceWithStreamingResponse:
+ from .resources.check_transfers import AsyncCheckTransfersResourceWithStreamingResponse
+
+ return AsyncCheckTransfersResourceWithStreamingResponse(self._client.check_transfers)
+
+ @cached_property
+ def inbound_check_deposits(self) -> AsyncInboundCheckDepositsResourceWithStreamingResponse:
+ from .resources.inbound_check_deposits import AsyncInboundCheckDepositsResourceWithStreamingResponse
+
+ return AsyncInboundCheckDepositsResourceWithStreamingResponse(self._client.inbound_check_deposits)
+
+ @cached_property
+ def real_time_payments_transfers(
+ self,
+ ) -> AsyncRealTimePaymentsTransfersResourceWithStreamingResponse:
+ from .resources.real_time_payments_transfers import AsyncRealTimePaymentsTransfersResourceWithStreamingResponse
+
+ return AsyncRealTimePaymentsTransfersResourceWithStreamingResponse(self._client.real_time_payments_transfers)
+
+ @cached_property
+ def inbound_real_time_payments_transfers(
+ self,
+ ) -> AsyncInboundRealTimePaymentsTransfersResourceWithStreamingResponse:
+ from .resources.inbound_real_time_payments_transfers import (
+ AsyncInboundRealTimePaymentsTransfersResourceWithStreamingResponse,
)
- self.card_validations = card_validations.AsyncCardValidationsResourceWithStreamingResponse(
- client.card_validations
+
+ return AsyncInboundRealTimePaymentsTransfersResourceWithStreamingResponse(
+ self._client.inbound_real_time_payments_transfers
)
- self.simulations = simulations.AsyncSimulationsResourceWithStreamingResponse(client.simulations)
+
+ @cached_property
+ def fednow_transfers(self) -> AsyncFednowTransfersResourceWithStreamingResponse:
+ from .resources.fednow_transfers import AsyncFednowTransfersResourceWithStreamingResponse
+
+ return AsyncFednowTransfersResourceWithStreamingResponse(self._client.fednow_transfers)
+
+ @cached_property
+ def inbound_fednow_transfers(
+ self,
+ ) -> AsyncInboundFednowTransfersResourceWithStreamingResponse:
+ from .resources.inbound_fednow_transfers import AsyncInboundFednowTransfersResourceWithStreamingResponse
+
+ return AsyncInboundFednowTransfersResourceWithStreamingResponse(self._client.inbound_fednow_transfers)
+
+ @cached_property
+ def check_deposits(self) -> AsyncCheckDepositsResourceWithStreamingResponse:
+ from .resources.check_deposits import AsyncCheckDepositsResourceWithStreamingResponse
+
+ return AsyncCheckDepositsResourceWithStreamingResponse(self._client.check_deposits)
+
+ @cached_property
+ def lockboxes(self) -> AsyncLockboxesResourceWithStreamingResponse:
+ from .resources.lockboxes import AsyncLockboxesResourceWithStreamingResponse
+
+ return AsyncLockboxesResourceWithStreamingResponse(self._client.lockboxes)
+
+ @cached_property
+ def inbound_mail_items(self) -> AsyncInboundMailItemsResourceWithStreamingResponse:
+ from .resources.inbound_mail_items import AsyncInboundMailItemsResourceWithStreamingResponse
+
+ return AsyncInboundMailItemsResourceWithStreamingResponse(self._client.inbound_mail_items)
+
+ @cached_property
+ def routing_numbers(self) -> AsyncRoutingNumbersResourceWithStreamingResponse:
+ from .resources.routing_numbers import AsyncRoutingNumbersResourceWithStreamingResponse
+
+ return AsyncRoutingNumbersResourceWithStreamingResponse(self._client.routing_numbers)
+
+ @cached_property
+ def external_accounts(self) -> AsyncExternalAccountsResourceWithStreamingResponse:
+ from .resources.external_accounts import AsyncExternalAccountsResourceWithStreamingResponse
+
+ return AsyncExternalAccountsResourceWithStreamingResponse(self._client.external_accounts)
+
+ @cached_property
+ def entities(self) -> AsyncEntitiesResourceWithStreamingResponse:
+ from .resources.entities import AsyncEntitiesResourceWithStreamingResponse
+
+ return AsyncEntitiesResourceWithStreamingResponse(self._client.entities)
+
+ @cached_property
+ def supplemental_documents(self) -> AsyncSupplementalDocumentsResourceWithStreamingResponse:
+ from .resources.supplemental_documents import AsyncSupplementalDocumentsResourceWithStreamingResponse
+
+ return AsyncSupplementalDocumentsResourceWithStreamingResponse(self._client.supplemental_documents)
+
+ @cached_property
+ def programs(self) -> AsyncProgramsResourceWithStreamingResponse:
+ from .resources.programs import AsyncProgramsResourceWithStreamingResponse
+
+ return AsyncProgramsResourceWithStreamingResponse(self._client.programs)
+
+ @cached_property
+ def account_statements(self) -> AsyncAccountStatementsResourceWithStreamingResponse:
+ from .resources.account_statements import AsyncAccountStatementsResourceWithStreamingResponse
+
+ return AsyncAccountStatementsResourceWithStreamingResponse(self._client.account_statements)
+
+ @cached_property
+ def files(self) -> AsyncFilesResourceWithStreamingResponse:
+ from .resources.files import AsyncFilesResourceWithStreamingResponse
+
+ return AsyncFilesResourceWithStreamingResponse(self._client.files)
+
+ @cached_property
+ def file_links(self) -> AsyncFileLinksResourceWithStreamingResponse:
+ from .resources.file_links import AsyncFileLinksResourceWithStreamingResponse
+
+ return AsyncFileLinksResourceWithStreamingResponse(self._client.file_links)
+
+ @cached_property
+ def exports(self) -> AsyncExportsResourceWithStreamingResponse:
+ from .resources.exports import AsyncExportsResourceWithStreamingResponse
+
+ return AsyncExportsResourceWithStreamingResponse(self._client.exports)
+
+ @cached_property
+ def events(self) -> AsyncEventsResourceWithStreamingResponse:
+ from .resources.events import AsyncEventsResourceWithStreamingResponse
+
+ return AsyncEventsResourceWithStreamingResponse(self._client.events)
+
+ @cached_property
+ def event_subscriptions(self) -> AsyncEventSubscriptionsResourceWithStreamingResponse:
+ from .resources.event_subscriptions import AsyncEventSubscriptionsResourceWithStreamingResponse
+
+ return AsyncEventSubscriptionsResourceWithStreamingResponse(self._client.event_subscriptions)
+
+ @cached_property
+ def real_time_decisions(self) -> AsyncRealTimeDecisionsResourceWithStreamingResponse:
+ from .resources.real_time_decisions import AsyncRealTimeDecisionsResourceWithStreamingResponse
+
+ return AsyncRealTimeDecisionsResourceWithStreamingResponse(self._client.real_time_decisions)
+
+ @cached_property
+ def bookkeeping_accounts(self) -> AsyncBookkeepingAccountsResourceWithStreamingResponse:
+ from .resources.bookkeeping_accounts import AsyncBookkeepingAccountsResourceWithStreamingResponse
+
+ return AsyncBookkeepingAccountsResourceWithStreamingResponse(self._client.bookkeeping_accounts)
+
+ @cached_property
+ def bookkeeping_entry_sets(self) -> AsyncBookkeepingEntrySetsResourceWithStreamingResponse:
+ from .resources.bookkeeping_entry_sets import AsyncBookkeepingEntrySetsResourceWithStreamingResponse
+
+ return AsyncBookkeepingEntrySetsResourceWithStreamingResponse(self._client.bookkeeping_entry_sets)
+
+ @cached_property
+ def bookkeeping_entries(self) -> AsyncBookkeepingEntriesResourceWithStreamingResponse:
+ from .resources.bookkeeping_entries import AsyncBookkeepingEntriesResourceWithStreamingResponse
+
+ return AsyncBookkeepingEntriesResourceWithStreamingResponse(self._client.bookkeeping_entries)
+
+ @cached_property
+ def groups(self) -> AsyncGroupsResourceWithStreamingResponse:
+ from .resources.groups import AsyncGroupsResourceWithStreamingResponse
+
+ return AsyncGroupsResourceWithStreamingResponse(self._client.groups)
+
+ @cached_property
+ def oauth_applications(self) -> AsyncOAuthApplicationsResourceWithStreamingResponse:
+ from .resources.oauth_applications import AsyncOAuthApplicationsResourceWithStreamingResponse
+
+ return AsyncOAuthApplicationsResourceWithStreamingResponse(self._client.oauth_applications)
+
+ @cached_property
+ def oauth_connections(self) -> AsyncOAuthConnectionsResourceWithStreamingResponse:
+ from .resources.oauth_connections import AsyncOAuthConnectionsResourceWithStreamingResponse
+
+ return AsyncOAuthConnectionsResourceWithStreamingResponse(self._client.oauth_connections)
+
+ @cached_property
+ def oauth_tokens(self) -> AsyncOAuthTokensResourceWithStreamingResponse:
+ from .resources.oauth_tokens import AsyncOAuthTokensResourceWithStreamingResponse
+
+ return AsyncOAuthTokensResourceWithStreamingResponse(self._client.oauth_tokens)
+
+ @cached_property
+ def intrafi_account_enrollments(
+ self,
+ ) -> AsyncIntrafiAccountEnrollmentsResourceWithStreamingResponse:
+ from .resources.intrafi_account_enrollments import AsyncIntrafiAccountEnrollmentsResourceWithStreamingResponse
+
+ return AsyncIntrafiAccountEnrollmentsResourceWithStreamingResponse(self._client.intrafi_account_enrollments)
+
+ @cached_property
+ def intrafi_balances(self) -> AsyncIntrafiBalancesResourceWithStreamingResponse:
+ from .resources.intrafi_balances import AsyncIntrafiBalancesResourceWithStreamingResponse
+
+ return AsyncIntrafiBalancesResourceWithStreamingResponse(self._client.intrafi_balances)
+
+ @cached_property
+ def intrafi_exclusions(self) -> AsyncIntrafiExclusionsResourceWithStreamingResponse:
+ from .resources.intrafi_exclusions import AsyncIntrafiExclusionsResourceWithStreamingResponse
+
+ return AsyncIntrafiExclusionsResourceWithStreamingResponse(self._client.intrafi_exclusions)
+
+ @cached_property
+ def card_tokens(self) -> AsyncCardTokensResourceWithStreamingResponse:
+ from .resources.card_tokens import AsyncCardTokensResourceWithStreamingResponse
+
+ return AsyncCardTokensResourceWithStreamingResponse(self._client.card_tokens)
+
+ @cached_property
+ def card_push_transfers(self) -> AsyncCardPushTransfersResourceWithStreamingResponse:
+ from .resources.card_push_transfers import AsyncCardPushTransfersResourceWithStreamingResponse
+
+ return AsyncCardPushTransfersResourceWithStreamingResponse(self._client.card_push_transfers)
+
+ @cached_property
+ def card_validations(self) -> AsyncCardValidationsResourceWithStreamingResponse:
+ from .resources.card_validations import AsyncCardValidationsResourceWithStreamingResponse
+
+ return AsyncCardValidationsResourceWithStreamingResponse(self._client.card_validations)
+
+ @cached_property
+ def simulations(self) -> AsyncSimulationsResourceWithStreamingResponse:
+ from .resources.simulations import AsyncSimulationsResourceWithStreamingResponse
+
+ return AsyncSimulationsResourceWithStreamingResponse(self._client.simulations)
Client = Increase
diff --git a/src/increase/_version.py b/src/increase/_version.py
index 5a8306020..942592aa8 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.416.0" # x-release-please-version
+__version__ = "0.417.0" # x-release-please-version
diff --git a/src/increase/resources/__init__.py b/src/increase/resources/__init__.py
index 9915c8358..24c33f0ba 100644
--- a/src/increase/resources/__init__.py
+++ b/src/increase/resources/__init__.py
@@ -65,14 +65,6 @@
AsyncProgramsResourceWithStreamingResponse,
)
from .webhooks import Webhooks, AsyncWebhooks
-from .documents import (
- DocumentsResource,
- AsyncDocumentsResource,
- DocumentsResourceWithRawResponse,
- AsyncDocumentsResourceWithRawResponse,
- DocumentsResourceWithStreamingResponse,
- AsyncDocumentsResourceWithStreamingResponse,
-)
from .lockboxes import (
LockboxesResource,
AsyncLockboxesResource,
@@ -689,12 +681,6 @@
"AsyncFileLinksResourceWithRawResponse",
"FileLinksResourceWithStreamingResponse",
"AsyncFileLinksResourceWithStreamingResponse",
- "DocumentsResource",
- "AsyncDocumentsResource",
- "DocumentsResourceWithRawResponse",
- "AsyncDocumentsResourceWithRawResponse",
- "DocumentsResourceWithStreamingResponse",
- "AsyncDocumentsResourceWithStreamingResponse",
"ExportsResource",
"AsyncExportsResource",
"ExportsResourceWithRawResponse",
diff --git a/src/increase/resources/documents.py b/src/increase/resources/documents.py
deleted file mode 100644
index 90b72744d..000000000
--- a/src/increase/resources/documents.py
+++ /dev/null
@@ -1,440 +0,0 @@
-# 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 document_list_params, document_create_params
-from .._types import Body, Omit, Query, Headers, NotGiven, omit, not_given
-from .._utils import maybe_transform, async_maybe_transform
-from .._compat import cached_property
-from .._resource import SyncAPIResource, AsyncAPIResource
-from .._response import (
- to_raw_response_wrapper,
- to_streamed_response_wrapper,
- async_to_raw_response_wrapper,
- async_to_streamed_response_wrapper,
-)
-from ..pagination import SyncPage, AsyncPage
-from .._base_client import AsyncPaginator, make_request_options
-from ..types.document import Document
-
-__all__ = ["DocumentsResource", "AsyncDocumentsResource"]
-
-
-class DocumentsResource(SyncAPIResource):
- @cached_property
- def with_raw_response(self) -> DocumentsResourceWithRawResponse:
- """
- 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 DocumentsResourceWithRawResponse(self)
-
- @cached_property
- def with_streaming_response(self) -> DocumentsResourceWithStreamingResponse:
- """
- 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 DocumentsResourceWithStreamingResponse(self)
-
- def create(
- self,
- *,
- category: Literal["account_verification_letter", "funding_instructions"],
- account_verification_letter: document_create_params.AccountVerificationLetter | Omit = omit,
- funding_instructions: document_create_params.FundingInstructions | 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,
- ) -> Document:
- """
- Create a Document
-
- Args:
- category: The type of document to create.
-
- - `account_verification_letter` - An account verification letter.
- - `funding_instructions` - Funding instructions.
-
- account_verification_letter: An account verification letter. Required if and only if `category` is
- `account_verification_letter`.
-
- funding_instructions: Funding instructions. Required if and only if `category` is
- `funding_instructions`.
-
- 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(
- "/documents",
- body=maybe_transform(
- {
- "category": category,
- "account_verification_letter": account_verification_letter,
- "funding_instructions": funding_instructions,
- },
- document_create_params.DocumentCreateParams,
- ),
- options=make_request_options(
- extra_headers=extra_headers,
- extra_query=extra_query,
- extra_body=extra_body,
- timeout=timeout,
- idempotency_key=idempotency_key,
- ),
- cast_to=Document,
- )
-
- def retrieve(
- self,
- document_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,
- ) -> Document:
- """
- Retrieve a Document
-
- Args:
- document_id: The identifier of the Document 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 document_id:
- raise ValueError(f"Expected a non-empty value for `document_id` but received {document_id!r}")
- return self._get(
- f"/documents/{document_id}",
- options=make_request_options(
- extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
- ),
- cast_to=Document,
- )
-
- def list(
- self,
- *,
- category: document_list_params.Category | Omit = omit,
- created_at: document_list_params.CreatedAt | Omit = omit,
- cursor: str | Omit = omit,
- entity_id: str | Omit = omit,
- idempotency_key: str | Omit = omit,
- limit: int | 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[Document]:
- """
- List Documents
-
- Args:
- cursor: Return the page of entries after this one.
-
- entity_id: Filter Documents to ones belonging to the specified Entity.
-
- 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(
- "/documents",
- page=SyncPage[Document],
- options=make_request_options(
- extra_headers=extra_headers,
- extra_query=extra_query,
- extra_body=extra_body,
- timeout=timeout,
- query=maybe_transform(
- {
- "category": category,
- "created_at": created_at,
- "cursor": cursor,
- "entity_id": entity_id,
- "idempotency_key": idempotency_key,
- "limit": limit,
- },
- document_list_params.DocumentListParams,
- ),
- ),
- model=Document,
- )
-
-
-class AsyncDocumentsResource(AsyncAPIResource):
- @cached_property
- def with_raw_response(self) -> AsyncDocumentsResourceWithRawResponse:
- """
- 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 AsyncDocumentsResourceWithRawResponse(self)
-
- @cached_property
- def with_streaming_response(self) -> AsyncDocumentsResourceWithStreamingResponse:
- """
- 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 AsyncDocumentsResourceWithStreamingResponse(self)
-
- async def create(
- self,
- *,
- category: Literal["account_verification_letter", "funding_instructions"],
- account_verification_letter: document_create_params.AccountVerificationLetter | Omit = omit,
- funding_instructions: document_create_params.FundingInstructions | 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,
- ) -> Document:
- """
- Create a Document
-
- Args:
- category: The type of document to create.
-
- - `account_verification_letter` - An account verification letter.
- - `funding_instructions` - Funding instructions.
-
- account_verification_letter: An account verification letter. Required if and only if `category` is
- `account_verification_letter`.
-
- funding_instructions: Funding instructions. Required if and only if `category` is
- `funding_instructions`.
-
- 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(
- "/documents",
- body=await async_maybe_transform(
- {
- "category": category,
- "account_verification_letter": account_verification_letter,
- "funding_instructions": funding_instructions,
- },
- document_create_params.DocumentCreateParams,
- ),
- options=make_request_options(
- extra_headers=extra_headers,
- extra_query=extra_query,
- extra_body=extra_body,
- timeout=timeout,
- idempotency_key=idempotency_key,
- ),
- cast_to=Document,
- )
-
- async def retrieve(
- self,
- document_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,
- ) -> Document:
- """
- Retrieve a Document
-
- Args:
- document_id: The identifier of the Document 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 document_id:
- raise ValueError(f"Expected a non-empty value for `document_id` but received {document_id!r}")
- return await self._get(
- f"/documents/{document_id}",
- options=make_request_options(
- extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
- ),
- cast_to=Document,
- )
-
- def list(
- self,
- *,
- category: document_list_params.Category | Omit = omit,
- created_at: document_list_params.CreatedAt | Omit = omit,
- cursor: str | Omit = omit,
- entity_id: str | Omit = omit,
- idempotency_key: str | Omit = omit,
- limit: int | 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[Document, AsyncPage[Document]]:
- """
- List Documents
-
- Args:
- cursor: Return the page of entries after this one.
-
- entity_id: Filter Documents to ones belonging to the specified Entity.
-
- 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(
- "/documents",
- page=AsyncPage[Document],
- options=make_request_options(
- extra_headers=extra_headers,
- extra_query=extra_query,
- extra_body=extra_body,
- timeout=timeout,
- query=maybe_transform(
- {
- "category": category,
- "created_at": created_at,
- "cursor": cursor,
- "entity_id": entity_id,
- "idempotency_key": idempotency_key,
- "limit": limit,
- },
- document_list_params.DocumentListParams,
- ),
- ),
- model=Document,
- )
-
-
-class DocumentsResourceWithRawResponse:
- def __init__(self, documents: DocumentsResource) -> None:
- self._documents = documents
-
- self.create = to_raw_response_wrapper(
- documents.create,
- )
- self.retrieve = to_raw_response_wrapper(
- documents.retrieve,
- )
- self.list = to_raw_response_wrapper(
- documents.list,
- )
-
-
-class AsyncDocumentsResourceWithRawResponse:
- def __init__(self, documents: AsyncDocumentsResource) -> None:
- self._documents = documents
-
- self.create = async_to_raw_response_wrapper(
- documents.create,
- )
- self.retrieve = async_to_raw_response_wrapper(
- documents.retrieve,
- )
- self.list = async_to_raw_response_wrapper(
- documents.list,
- )
-
-
-class DocumentsResourceWithStreamingResponse:
- def __init__(self, documents: DocumentsResource) -> None:
- self._documents = documents
-
- self.create = to_streamed_response_wrapper(
- documents.create,
- )
- self.retrieve = to_streamed_response_wrapper(
- documents.retrieve,
- )
- self.list = to_streamed_response_wrapper(
- documents.list,
- )
-
-
-class AsyncDocumentsResourceWithStreamingResponse:
- def __init__(self, documents: AsyncDocumentsResource) -> None:
- self._documents = documents
-
- self.create = async_to_streamed_response_wrapper(
- documents.create,
- )
- self.retrieve = async_to_streamed_response_wrapper(
- documents.retrieve,
- )
- self.list = async_to_streamed_response_wrapper(
- documents.list,
- )
diff --git a/src/increase/resources/exports.py b/src/increase/resources/exports.py
index 754a1a9dd..f58378da1 100644
--- a/src/increase/resources/exports.py
+++ b/src/increase/resources/exports.py
@@ -55,12 +55,16 @@ def create(
"bookkeeping_account_balance_csv",
"entity_csv",
"vendor_csv",
+ "account_verification_letter",
+ "funding_instructions",
],
account_statement_bai2: export_create_params.AccountStatementBai2 | Omit = omit,
account_statement_ofx: export_create_params.AccountStatementOfx | Omit = omit,
+ account_verification_letter: export_create_params.AccountVerificationLetter | Omit = omit,
balance_csv: export_create_params.BalanceCsv | Omit = omit,
bookkeeping_account_balance_csv: export_create_params.BookkeepingAccountBalanceCsv | Omit = omit,
entity_csv: export_create_params.EntityCsv | Omit = omit,
+ funding_instructions: export_create_params.FundingInstructions | Omit = omit,
transaction_csv: export_create_params.TransactionCsv | Omit = omit,
vendor_csv: export_create_params.VendorCsv | Omit = omit,
# Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
@@ -89,6 +93,8 @@ def create(
- `entity_csv` - Export a CSV of entities with a given status.
- `vendor_csv` - Export a CSV of vendors added to the third-party risk
management dashboard.
+ - `account_verification_letter` - A PDF of an account verification letter.
+ - `funding_instructions` - A PDF of funding instructions.
account_statement_bai2: Options for the created export. Required if `category` is equal to
`account_statement_bai2`.
@@ -96,6 +102,9 @@ def create(
account_statement_ofx: Options for the created export. Required if `category` is equal to
`account_statement_ofx`.
+ account_verification_letter: Options for the created export. Required if `category` is equal to
+ `account_verification_letter`.
+
balance_csv: Options for the created export. Required if `category` is equal to
`balance_csv`.
@@ -104,6 +113,9 @@ def create(
entity_csv: Options for the created export. Required if `category` is equal to `entity_csv`.
+ funding_instructions: Options for the created export. Required if `category` is equal to
+ `funding_instructions`.
+
transaction_csv: Options for the created export. Required if `category` is equal to
`transaction_csv`.
@@ -126,9 +138,11 @@ def create(
"category": category,
"account_statement_bai2": account_statement_bai2,
"account_statement_ofx": account_statement_ofx,
+ "account_verification_letter": account_verification_letter,
"balance_csv": balance_csv,
"bookkeeping_account_balance_csv": bookkeeping_account_balance_csv,
"entity_csv": entity_csv,
+ "funding_instructions": funding_instructions,
"transaction_csv": transaction_csv,
"vendor_csv": vendor_csv,
},
@@ -272,12 +286,16 @@ async def create(
"bookkeeping_account_balance_csv",
"entity_csv",
"vendor_csv",
+ "account_verification_letter",
+ "funding_instructions",
],
account_statement_bai2: export_create_params.AccountStatementBai2 | Omit = omit,
account_statement_ofx: export_create_params.AccountStatementOfx | Omit = omit,
+ account_verification_letter: export_create_params.AccountVerificationLetter | Omit = omit,
balance_csv: export_create_params.BalanceCsv | Omit = omit,
bookkeeping_account_balance_csv: export_create_params.BookkeepingAccountBalanceCsv | Omit = omit,
entity_csv: export_create_params.EntityCsv | Omit = omit,
+ funding_instructions: export_create_params.FundingInstructions | Omit = omit,
transaction_csv: export_create_params.TransactionCsv | Omit = omit,
vendor_csv: export_create_params.VendorCsv | Omit = omit,
# Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
@@ -306,6 +324,8 @@ async def create(
- `entity_csv` - Export a CSV of entities with a given status.
- `vendor_csv` - Export a CSV of vendors added to the third-party risk
management dashboard.
+ - `account_verification_letter` - A PDF of an account verification letter.
+ - `funding_instructions` - A PDF of funding instructions.
account_statement_bai2: Options for the created export. Required if `category` is equal to
`account_statement_bai2`.
@@ -313,6 +333,9 @@ async def create(
account_statement_ofx: Options for the created export. Required if `category` is equal to
`account_statement_ofx`.
+ account_verification_letter: Options for the created export. Required if `category` is equal to
+ `account_verification_letter`.
+
balance_csv: Options for the created export. Required if `category` is equal to
`balance_csv`.
@@ -321,6 +344,9 @@ async def create(
entity_csv: Options for the created export. Required if `category` is equal to `entity_csv`.
+ funding_instructions: Options for the created export. Required if `category` is equal to
+ `funding_instructions`.
+
transaction_csv: Options for the created export. Required if `category` is equal to
`transaction_csv`.
@@ -343,9 +369,11 @@ async def create(
"category": category,
"account_statement_bai2": account_statement_bai2,
"account_statement_ofx": account_statement_ofx,
+ "account_verification_letter": account_verification_letter,
"balance_csv": balance_csv,
"bookkeeping_account_balance_csv": bookkeeping_account_balance_csv,
"entity_csv": entity_csv,
+ "funding_instructions": funding_instructions,
"transaction_csv": transaction_csv,
"vendor_csv": vendor_csv,
},
diff --git a/src/increase/resources/inbound_wire_transfers.py b/src/increase/resources/inbound_wire_transfers.py
index 964804140..1cee06f11 100644
--- a/src/increase/resources/inbound_wire_transfers.py
+++ b/src/increase/resources/inbound_wire_transfers.py
@@ -150,7 +150,7 @@ def reverse(
self,
inbound_wire_transfer_id: str,
*,
- reason: Literal["duplicate", "creditor_request"],
+ reason: Literal["duplicate", "creditor_request", "transaction_forbidden"],
# 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,
@@ -170,6 +170,7 @@ def reverse(
- `duplicate` - The inbound wire transfer was a duplicate.
- `creditor_request` - The recipient of the wire transfer requested the funds be
returned to the sender.
+ - `transaction_forbidden` - The account cannot currently receive inbound wires.
extra_headers: Send extra headers
@@ -327,7 +328,7 @@ async def reverse(
self,
inbound_wire_transfer_id: str,
*,
- reason: Literal["duplicate", "creditor_request"],
+ reason: Literal["duplicate", "creditor_request", "transaction_forbidden"],
# 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,
@@ -347,6 +348,7 @@ async def reverse(
- `duplicate` - The inbound wire transfer was a duplicate.
- `creditor_request` - The recipient of the wire transfer requested the funds be
returned to the sender.
+ - `transaction_forbidden` - The account cannot currently receive inbound wires.
extra_headers: Send extra headers
diff --git a/src/increase/resources/simulations/__init__.py b/src/increase/resources/simulations/__init__.py
index 5366a0c9c..93e0e270f 100644
--- a/src/increase/resources/simulations/__init__.py
+++ b/src/increase/resources/simulations/__init__.py
@@ -1,5 +1,13 @@
# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+from .exports import (
+ ExportsResource,
+ AsyncExportsResource,
+ ExportsResourceWithRawResponse,
+ AsyncExportsResourceWithRawResponse,
+ ExportsResourceWithStreamingResponse,
+ AsyncExportsResourceWithStreamingResponse,
+)
from .programs import (
ProgramsResource,
AsyncProgramsResource,
@@ -8,14 +16,6 @@
ProgramsResourceWithStreamingResponse,
AsyncProgramsResourceWithStreamingResponse,
)
-from .documents import (
- DocumentsResource,
- AsyncDocumentsResource,
- DocumentsResourceWithRawResponse,
- AsyncDocumentsResourceWithRawResponse,
- DocumentsResourceWithStreamingResponse,
- AsyncDocumentsResourceWithStreamingResponse,
-)
from .card_tokens import (
CardTokensResource,
AsyncCardTokensResource,
@@ -432,12 +432,12 @@
"AsyncAccountStatementsResourceWithRawResponse",
"AccountStatementsResourceWithStreamingResponse",
"AsyncAccountStatementsResourceWithStreamingResponse",
- "DocumentsResource",
- "AsyncDocumentsResource",
- "DocumentsResourceWithRawResponse",
- "AsyncDocumentsResourceWithRawResponse",
- "DocumentsResourceWithStreamingResponse",
- "AsyncDocumentsResourceWithStreamingResponse",
+ "ExportsResource",
+ "AsyncExportsResource",
+ "ExportsResourceWithRawResponse",
+ "AsyncExportsResourceWithRawResponse",
+ "ExportsResourceWithStreamingResponse",
+ "AsyncExportsResourceWithStreamingResponse",
"CardTokensResource",
"AsyncCardTokensResource",
"CardTokensResourceWithRawResponse",
diff --git a/src/increase/resources/simulations/documents.py b/src/increase/resources/simulations/exports.py
similarity index 54%
rename from src/increase/resources/simulations/documents.py
rename to src/increase/resources/simulations/exports.py
index 0f85ae779..2ff9a2b66 100644
--- a/src/increase/resources/simulations/documents.py
+++ b/src/increase/resources/simulations/exports.py
@@ -2,9 +2,11 @@
from __future__ import annotations
+from typing_extensions import Literal
+
import httpx
-from ..._types import Body, Query, Headers, NotGiven, not_given
+from ..._types import Body, Omit, Query, Headers, NotGiven, omit, not_given
from ..._utils import maybe_transform, async_maybe_transform
from ..._compat import cached_property
from ..._resource import SyncAPIResource, AsyncAPIResource
@@ -15,36 +17,37 @@
async_to_streamed_response_wrapper,
)
from ..._base_client import make_request_options
-from ...types.document import Document
-from ...types.simulations import document_create_params
+from ...types.export import Export
+from ...types.simulations import export_create_params
-__all__ = ["DocumentsResource", "AsyncDocumentsResource"]
+__all__ = ["ExportsResource", "AsyncExportsResource"]
-class DocumentsResource(SyncAPIResource):
+class ExportsResource(SyncAPIResource):
@cached_property
- def with_raw_response(self) -> DocumentsResourceWithRawResponse:
+ def with_raw_response(self) -> ExportsResourceWithRawResponse:
"""
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 DocumentsResourceWithRawResponse(self)
+ return ExportsResourceWithRawResponse(self)
@cached_property
- def with_streaming_response(self) -> DocumentsResourceWithStreamingResponse:
+ def with_streaming_response(self) -> ExportsResourceWithStreamingResponse:
"""
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 DocumentsResourceWithStreamingResponse(self)
+ return ExportsResourceWithStreamingResponse(self)
def create(
self,
*,
- account_id: str,
+ category: Literal["form_1099_int"],
+ form_1099_int: export_create_params.Form1099Int | 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,
@@ -52,12 +55,21 @@ def create(
extra_body: Body | None = None,
timeout: float | httpx.Timeout | None | NotGiven = not_given,
idempotency_key: str | None = None,
- ) -> Document:
- """
- Simulates an tax document being created for an account.
+ ) -> Export:
+ """Many exports are created by you via POST /exports or in the Dashboard.
+
+ Some
+ exports are created automatically by Increase. For example, tax documents are
+ published once a year. In sandbox, you can trigger the arrival of an export that
+ would normally only be created automatically via this simulation.
Args:
- account_id: The identifier of the Account the tax document is for.
+ category: The type of Export to create.
+
+ - `form_1099_int` - A PDF of an Internal Revenue Service Form 1099-INT.
+
+ form_1099_int: Options for the created export. Required if `category` is equal to
+ `form_1099_int`.
extra_headers: Send extra headers
@@ -70,8 +82,14 @@ def create(
idempotency_key: Specify a custom idempotency key for this request
"""
return self._post(
- "/simulations/documents",
- body=maybe_transform({"account_id": account_id}, document_create_params.DocumentCreateParams),
+ "/simulations/exports",
+ body=maybe_transform(
+ {
+ "category": category,
+ "form_1099_int": form_1099_int,
+ },
+ export_create_params.ExportCreateParams,
+ ),
options=make_request_options(
extra_headers=extra_headers,
extra_query=extra_query,
@@ -79,34 +97,35 @@ def create(
timeout=timeout,
idempotency_key=idempotency_key,
),
- cast_to=Document,
+ cast_to=Export,
)
-class AsyncDocumentsResource(AsyncAPIResource):
+class AsyncExportsResource(AsyncAPIResource):
@cached_property
- def with_raw_response(self) -> AsyncDocumentsResourceWithRawResponse:
+ def with_raw_response(self) -> AsyncExportsResourceWithRawResponse:
"""
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 AsyncDocumentsResourceWithRawResponse(self)
+ return AsyncExportsResourceWithRawResponse(self)
@cached_property
- def with_streaming_response(self) -> AsyncDocumentsResourceWithStreamingResponse:
+ def with_streaming_response(self) -> AsyncExportsResourceWithStreamingResponse:
"""
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 AsyncDocumentsResourceWithStreamingResponse(self)
+ return AsyncExportsResourceWithStreamingResponse(self)
async def create(
self,
*,
- account_id: str,
+ category: Literal["form_1099_int"],
+ form_1099_int: export_create_params.Form1099Int | 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,
@@ -114,12 +133,21 @@ async def create(
extra_body: Body | None = None,
timeout: float | httpx.Timeout | None | NotGiven = not_given,
idempotency_key: str | None = None,
- ) -> Document:
- """
- Simulates an tax document being created for an account.
+ ) -> Export:
+ """Many exports are created by you via POST /exports or in the Dashboard.
+
+ Some
+ exports are created automatically by Increase. For example, tax documents are
+ published once a year. In sandbox, you can trigger the arrival of an export that
+ would normally only be created automatically via this simulation.
Args:
- account_id: The identifier of the Account the tax document is for.
+ category: The type of Export to create.
+
+ - `form_1099_int` - A PDF of an Internal Revenue Service Form 1099-INT.
+
+ form_1099_int: Options for the created export. Required if `category` is equal to
+ `form_1099_int`.
extra_headers: Send extra headers
@@ -132,8 +160,14 @@ async def create(
idempotency_key: Specify a custom idempotency key for this request
"""
return await self._post(
- "/simulations/documents",
- body=await async_maybe_transform({"account_id": account_id}, document_create_params.DocumentCreateParams),
+ "/simulations/exports",
+ body=await async_maybe_transform(
+ {
+ "category": category,
+ "form_1099_int": form_1099_int,
+ },
+ export_create_params.ExportCreateParams,
+ ),
options=make_request_options(
extra_headers=extra_headers,
extra_query=extra_query,
@@ -141,41 +175,41 @@ async def create(
timeout=timeout,
idempotency_key=idempotency_key,
),
- cast_to=Document,
+ cast_to=Export,
)
-class DocumentsResourceWithRawResponse:
- def __init__(self, documents: DocumentsResource) -> None:
- self._documents = documents
+class ExportsResourceWithRawResponse:
+ def __init__(self, exports: ExportsResource) -> None:
+ self._exports = exports
self.create = to_raw_response_wrapper(
- documents.create,
+ exports.create,
)
-class AsyncDocumentsResourceWithRawResponse:
- def __init__(self, documents: AsyncDocumentsResource) -> None:
- self._documents = documents
+class AsyncExportsResourceWithRawResponse:
+ def __init__(self, exports: AsyncExportsResource) -> None:
+ self._exports = exports
self.create = async_to_raw_response_wrapper(
- documents.create,
+ exports.create,
)
-class DocumentsResourceWithStreamingResponse:
- def __init__(self, documents: DocumentsResource) -> None:
- self._documents = documents
+class ExportsResourceWithStreamingResponse:
+ def __init__(self, exports: ExportsResource) -> None:
+ self._exports = exports
self.create = to_streamed_response_wrapper(
- documents.create,
+ exports.create,
)
-class AsyncDocumentsResourceWithStreamingResponse:
- def __init__(self, documents: AsyncDocumentsResource) -> None:
- self._documents = documents
+class AsyncExportsResourceWithStreamingResponse:
+ def __init__(self, exports: AsyncExportsResource) -> None:
+ self._exports = exports
self.create = async_to_streamed_response_wrapper(
- documents.create,
+ exports.create,
)
diff --git a/src/increase/resources/simulations/simulations.py b/src/increase/resources/simulations/simulations.py
index f02536d09..e5c83ebc7 100644
--- a/src/increase/resources/simulations/simulations.py
+++ b/src/increase/resources/simulations/simulations.py
@@ -2,6 +2,14 @@
from __future__ import annotations
+from .exports import (
+ ExportsResource,
+ AsyncExportsResource,
+ ExportsResourceWithRawResponse,
+ AsyncExportsResourceWithRawResponse,
+ ExportsResourceWithStreamingResponse,
+ AsyncExportsResourceWithStreamingResponse,
+)
from .programs import (
ProgramsResource,
AsyncProgramsResource,
@@ -11,14 +19,6 @@
AsyncProgramsResourceWithStreamingResponse,
)
from ..._compat import cached_property
-from .documents import (
- DocumentsResource,
- AsyncDocumentsResource,
- DocumentsResourceWithRawResponse,
- AsyncDocumentsResourceWithRawResponse,
- DocumentsResourceWithStreamingResponse,
- AsyncDocumentsResourceWithStreamingResponse,
-)
from ..._resource import SyncAPIResource, AsyncAPIResource
from .card_tokens import (
CardTokensResource,
@@ -374,8 +374,8 @@ def account_statements(self) -> AccountStatementsResource:
return AccountStatementsResource(self._client)
@cached_property
- def documents(self) -> DocumentsResource:
- return DocumentsResource(self._client)
+ def exports(self) -> ExportsResource:
+ return ExportsResource(self._client)
@cached_property
def card_tokens(self) -> CardTokensResource:
@@ -519,8 +519,8 @@ def account_statements(self) -> AsyncAccountStatementsResource:
return AsyncAccountStatementsResource(self._client)
@cached_property
- def documents(self) -> AsyncDocumentsResource:
- return AsyncDocumentsResource(self._client)
+ def exports(self) -> AsyncExportsResource:
+ return AsyncExportsResource(self._client)
@cached_property
def card_tokens(self) -> AsyncCardTokensResource:
@@ -669,8 +669,8 @@ def account_statements(self) -> AccountStatementsResourceWithRawResponse:
return AccountStatementsResourceWithRawResponse(self._simulations.account_statements)
@cached_property
- def documents(self) -> DocumentsResourceWithRawResponse:
- return DocumentsResourceWithRawResponse(self._simulations.documents)
+ def exports(self) -> ExportsResourceWithRawResponse:
+ return ExportsResourceWithRawResponse(self._simulations.exports)
@cached_property
def card_tokens(self) -> CardTokensResourceWithRawResponse:
@@ -802,8 +802,8 @@ def account_statements(self) -> AsyncAccountStatementsResourceWithRawResponse:
return AsyncAccountStatementsResourceWithRawResponse(self._simulations.account_statements)
@cached_property
- def documents(self) -> AsyncDocumentsResourceWithRawResponse:
- return AsyncDocumentsResourceWithRawResponse(self._simulations.documents)
+ def exports(self) -> AsyncExportsResourceWithRawResponse:
+ return AsyncExportsResourceWithRawResponse(self._simulations.exports)
@cached_property
def card_tokens(self) -> AsyncCardTokensResourceWithRawResponse:
@@ -937,8 +937,8 @@ def account_statements(self) -> AccountStatementsResourceWithStreamingResponse:
return AccountStatementsResourceWithStreamingResponse(self._simulations.account_statements)
@cached_property
- def documents(self) -> DocumentsResourceWithStreamingResponse:
- return DocumentsResourceWithStreamingResponse(self._simulations.documents)
+ def exports(self) -> ExportsResourceWithStreamingResponse:
+ return ExportsResourceWithStreamingResponse(self._simulations.exports)
@cached_property
def card_tokens(self) -> CardTokensResourceWithStreamingResponse:
@@ -1078,8 +1078,8 @@ def account_statements(self) -> AsyncAccountStatementsResourceWithStreamingRespo
return AsyncAccountStatementsResourceWithStreamingResponse(self._simulations.account_statements)
@cached_property
- def documents(self) -> AsyncDocumentsResourceWithStreamingResponse:
- return AsyncDocumentsResourceWithStreamingResponse(self._simulations.documents)
+ def exports(self) -> AsyncExportsResourceWithStreamingResponse:
+ return AsyncExportsResourceWithStreamingResponse(self._simulations.exports)
@cached_property
def card_tokens(self) -> AsyncCardTokensResourceWithStreamingResponse:
diff --git a/src/increase/types/__init__.py b/src/increase/types/__init__.py
index 6eaf9bf97..c4fc145fa 100644
--- a/src/increase/types/__init__.py
+++ b/src/increase/types/__init__.py
@@ -11,7 +11,6 @@
from .account import Account as Account
from .lockbox import Lockbox as Lockbox
from .program import Program as Program
-from .document import Document as Document
from .file_link import FileLink as FileLink
from .card_token import CardToken as CardToken
from .oauth_token import OAuthToken as OAuthToken
@@ -58,7 +57,6 @@
from .declined_transaction import DeclinedTransaction as DeclinedTransaction
from .digital_card_profile import DigitalCardProfile as DigitalCardProfile
from .digital_wallet_token import DigitalWalletToken as DigitalWalletToken
-from .document_list_params import DocumentListParams as DocumentListParams
from .entity_create_params import EntityCreateParams as EntityCreateParams
from .entity_update_params import EntityUpdateParams as EntityUpdateParams
from .export_create_params import ExportCreateParams as ExportCreateParams
@@ -76,7 +74,6 @@
from .account_balance_params import AccountBalanceParams as AccountBalanceParams
from .card_token_list_params import CardTokenListParams as CardTokenListParams
from .card_update_pin_params import CardUpdatePinParams as CardUpdatePinParams
-from .document_create_params import DocumentCreateParams as DocumentCreateParams
from .card_token_capabilities import CardTokenCapabilities as CardTokenCapabilities
from .file_link_create_params import FileLinkCreateParams as FileLinkCreateParams
from .inbound_fednow_transfer import InboundFednowTransfer as InboundFednowTransfer
diff --git a/src/increase/types/document.py b/src/increase/types/document.py
deleted file mode 100644
index 0e2604ffc..000000000
--- a/src/increase/types/document.py
+++ /dev/null
@@ -1,84 +0,0 @@
-# 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__ = ["Document", "AccountVerificationLetter", "FundingInstructions"]
-
-
-class AccountVerificationLetter(BaseModel):
- """Properties of an account verification letter document."""
-
- account_number_id: str
- """The identifier of the Account Number the document was generated for."""
-
-
-class FundingInstructions(BaseModel):
- """Properties of a funding instructions document."""
-
- account_number_id: str
- """The identifier of the Account Number the document was generated for."""
-
-
-class Document(BaseModel):
- """
- Increase generates certain documents / forms automatically for your application; they can be listed here.
- """
-
- id: str
- """The Document identifier."""
-
- account_verification_letter: Optional[AccountVerificationLetter] = None
- """Properties of an account verification letter document."""
-
- category: Literal[
- "form_1099_int",
- "form_1099_misc",
- "proof_of_authorization",
- "company_information",
- "account_verification_letter",
- "funding_instructions",
- ]
- """The type of document.
-
- - `form_1099_int` - Internal Revenue Service Form 1099-INT.
- - `form_1099_misc` - Internal Revenue Service Form 1099-MISC.
- - `proof_of_authorization` - A document submitted in response to a proof of
- authorization request for an ACH transfer.
- - `company_information` - Company information, such a policies or procedures,
- typically submitted during our due diligence process.
- - `account_verification_letter` - An account verification letter.
- - `funding_instructions` - Funding instructions.
- """
-
- created_at: datetime
- """
- The [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) time at which the
- Document was created.
- """
-
- entity_id: Optional[str] = None
- """The identifier of the Entity the document was generated for."""
-
- file_id: str
- """The identifier of the File containing the Document's contents."""
-
- funding_instructions: Optional[FundingInstructions] = None
- """Properties of a funding instructions document."""
-
- 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).
- """
-
- type: Literal["document"]
- """A constant representing the object's type.
-
- For this resource it will always be `document`.
- """
diff --git a/src/increase/types/document_create_params.py b/src/increase/types/document_create_params.py
deleted file mode 100644
index 61dfa4d6b..000000000
--- a/src/increase/types/document_create_params.py
+++ /dev/null
@@ -1,55 +0,0 @@
-# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-from __future__ import annotations
-
-from typing import Union
-from datetime import date
-from typing_extensions import Literal, Required, Annotated, TypedDict
-
-from .._utils import PropertyInfo
-
-__all__ = ["DocumentCreateParams", "AccountVerificationLetter", "FundingInstructions"]
-
-
-class DocumentCreateParams(TypedDict, total=False):
- category: Required[Literal["account_verification_letter", "funding_instructions"]]
- """The type of document to create.
-
- - `account_verification_letter` - An account verification letter.
- - `funding_instructions` - Funding instructions.
- """
-
- account_verification_letter: AccountVerificationLetter
- """An account verification letter.
-
- Required if and only if `category` is `account_verification_letter`.
- """
-
- funding_instructions: FundingInstructions
- """Funding instructions.
-
- Required if and only if `category` is `funding_instructions`.
- """
-
-
-class AccountVerificationLetter(TypedDict, total=False):
- """An account verification letter.
-
- Required if and only if `category` is `account_verification_letter`.
- """
-
- account_number_id: Required[str]
- """The Account Number the bank letter should be generated for."""
-
- balance_date: Annotated[Union[str, date], PropertyInfo(format="iso8601")]
- """If provided, the letter will include the Account's balance as of the date."""
-
-
-class FundingInstructions(TypedDict, total=False):
- """Funding instructions.
-
- Required if and only if `category` is `funding_instructions`.
- """
-
- account_number_id: Required[str]
- """The Account Number the funding instructions should be generated for."""
diff --git a/src/increase/types/document_list_params.py b/src/increase/types/document_list_params.py
deleted file mode 100644
index 2e12d424d..000000000
--- a/src/increase/types/document_list_params.py
+++ /dev/null
@@ -1,85 +0,0 @@
-# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-from __future__ import annotations
-
-from typing import List, Union
-from datetime import datetime
-from typing_extensions import Literal, Annotated, TypedDict
-
-from .._utils import PropertyInfo
-
-__all__ = ["DocumentListParams", "Category", "CreatedAt"]
-
-
-class DocumentListParams(TypedDict, total=False):
- category: Category
-
- created_at: CreatedAt
-
- cursor: str
- """Return the page of entries after this one."""
-
- entity_id: str
- """Filter Documents to ones belonging to the specified Entity."""
-
- 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.
- """
-
-
-_CategoryReservedKeywords = TypedDict(
- "_CategoryReservedKeywords",
- {
- "in": List[
- Literal[
- "form_1099_int",
- "form_1099_misc",
- "proof_of_authorization",
- "company_information",
- "account_verification_letter",
- "funding_instructions",
- ]
- ],
- },
- total=False,
-)
-
-
-class Category(_CategoryReservedKeywords, total=False):
- pass
-
-
-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/export.py b/src/increase/types/export.py
index e8a36d78b..4ec5c7719 100644
--- a/src/increase/types/export.py
+++ b/src/increase/types/export.py
@@ -10,9 +10,9 @@
class Export(BaseModel):
- """Exports are batch summaries of your Increase data.
+ """Exports are generated files.
- You can make them from the API or dashboard. Since they can take a while, they are generated asynchronously. We send a webhook when they are ready. For more information, please read our [Exports documentation](https://increase.com/documentation/exports).
+ Some exports can contain a lot of data, like a CSV of your transactions. Others can be a single document, like a tax form. Since they can take a while, they are generated asynchronously. We send a webhook when they are ready. For more information, please read our [Exports documentation](https://increase.com/documentation/exports).
"""
id: str
@@ -27,6 +27,10 @@ class Export(BaseModel):
"entity_csv",
"vendor_csv",
"dashboard_table_csv",
+ "account_verification_letter",
+ "funding_instructions",
+ "form_1099_int",
+ "form_1099_misc",
]
"""The category of the Export.
@@ -47,6 +51,10 @@ class Export(BaseModel):
management dashboard.
- `dashboard_table_csv` - Certain dashboard tables are available as CSV exports.
This export cannot be created via the API.
+ - `account_verification_letter` - A PDF of an account verification letter.
+ - `funding_instructions` - A PDF of funding instructions.
+ - `form_1099_int` - A PDF of an Internal Revenue Service Form 1099-INT.
+ - `form_1099_misc` - A PDF of an Internal Revenue Service Form 1099-MISC.
"""
created_at: datetime
diff --git a/src/increase/types/export_create_params.py b/src/increase/types/export_create_params.py
index 54e5adb30..47ce43b19 100644
--- a/src/increase/types/export_create_params.py
+++ b/src/increase/types/export_create_params.py
@@ -13,12 +13,14 @@
"AccountStatementBai2",
"AccountStatementOfx",
"AccountStatementOfxCreatedAt",
+ "AccountVerificationLetter",
"BalanceCsv",
"BalanceCsvCreatedAt",
"BookkeepingAccountBalanceCsv",
"BookkeepingAccountBalanceCsvCreatedAt",
"EntityCsv",
"EntityCsvStatus",
+ "FundingInstructions",
"TransactionCsv",
"TransactionCsvCreatedAt",
"VendorCsv",
@@ -35,6 +37,8 @@ class ExportCreateParams(TypedDict, total=False):
"bookkeeping_account_balance_csv",
"entity_csv",
"vendor_csv",
+ "account_verification_letter",
+ "funding_instructions",
]
]
"""The type of Export to create.
@@ -51,6 +55,8 @@ class ExportCreateParams(TypedDict, total=False):
- `entity_csv` - Export a CSV of entities with a given status.
- `vendor_csv` - Export a CSV of vendors added to the third-party risk
management dashboard.
+ - `account_verification_letter` - A PDF of an account verification letter.
+ - `funding_instructions` - A PDF of funding instructions.
"""
account_statement_bai2: AccountStatementBai2
@@ -65,6 +71,12 @@ class ExportCreateParams(TypedDict, total=False):
Required if `category` is equal to `account_statement_ofx`.
"""
+ account_verification_letter: AccountVerificationLetter
+ """Options for the created export.
+
+ Required if `category` is equal to `account_verification_letter`.
+ """
+
balance_csv: BalanceCsv
"""Options for the created export.
@@ -83,6 +95,12 @@ class ExportCreateParams(TypedDict, total=False):
Required if `category` is equal to `entity_csv`.
"""
+ funding_instructions: FundingInstructions
+ """Options for the created export.
+
+ Required if `category` is equal to `funding_instructions`.
+ """
+
transaction_csv: TransactionCsv
"""Options for the created export.
@@ -164,6 +182,19 @@ class AccountStatementOfx(TypedDict, total=False):
"""Filter results by time range on the `created_at` attribute."""
+class AccountVerificationLetter(TypedDict, total=False):
+ """Options for the created export.
+
+ Required if `category` is equal to `account_verification_letter`.
+ """
+
+ account_number_id: Required[str]
+ """The Account Number to create a letter for."""
+
+ balance_date: Annotated[Union[str, date], PropertyInfo(format="iso8601")]
+ """The date of the balance to include in the letter. Defaults to the current date."""
+
+
class BalanceCsvCreatedAt(TypedDict, total=False):
"""Filter results by time range on the `created_at` attribute."""
@@ -274,6 +305,16 @@ class EntityCsv(TypedDict, total=False):
"""Entity statuses to filter by."""
+class FundingInstructions(TypedDict, total=False):
+ """Options for the created export.
+
+ Required if `category` is equal to `funding_instructions`.
+ """
+
+ account_number_id: Required[str]
+ """The Account Number to create funding instructions for."""
+
+
class TransactionCsvCreatedAt(TypedDict, total=False):
"""Filter results by time range on the `created_at` attribute."""
diff --git a/src/increase/types/export_list_params.py b/src/increase/types/export_list_params.py
index 237a7ceaa..3ba2c1ea6 100644
--- a/src/increase/types/export_list_params.py
+++ b/src/increase/types/export_list_params.py
@@ -49,6 +49,10 @@ class ExportListParams(TypedDict, total=False):
"entity_csv",
"vendor_csv",
"dashboard_table_csv",
+ "account_verification_letter",
+ "funding_instructions",
+ "form_1099_int",
+ "form_1099_misc",
]
],
},
diff --git a/src/increase/types/inbound_wire_transfer.py b/src/increase/types/inbound_wire_transfer.py
index 8b7faee00..5c4993263 100644
--- a/src/increase/types/inbound_wire_transfer.py
+++ b/src/increase/types/inbound_wire_transfer.py
@@ -16,12 +16,13 @@ class Reversal(BaseModel):
Information about the reversal of the inbound wire transfer if it has been reversed.
"""
- reason: Literal["duplicate", "creditor_request"]
+ reason: Literal["duplicate", "creditor_request", "transaction_forbidden"]
"""The reason for the reversal.
- `duplicate` - The inbound wire transfer was a duplicate.
- `creditor_request` - The recipient of the wire transfer requested the funds be
returned to the sender.
+ - `transaction_forbidden` - The account cannot currently receive inbound wires.
"""
reversed_at: datetime
diff --git a/src/increase/types/inbound_wire_transfer_reverse_params.py b/src/increase/types/inbound_wire_transfer_reverse_params.py
index 871521cf2..6bee104c6 100644
--- a/src/increase/types/inbound_wire_transfer_reverse_params.py
+++ b/src/increase/types/inbound_wire_transfer_reverse_params.py
@@ -8,10 +8,11 @@
class InboundWireTransferReverseParams(TypedDict, total=False):
- reason: Required[Literal["duplicate", "creditor_request"]]
+ reason: Required[Literal["duplicate", "creditor_request", "transaction_forbidden"]]
"""Reason for the reversal.
- `duplicate` - The inbound wire transfer was a duplicate.
- `creditor_request` - The recipient of the wire transfer requested the funds be
returned to the sender.
+ - `transaction_forbidden` - The account cannot currently receive inbound wires.
"""
diff --git a/src/increase/types/simulations/__init__.py b/src/increase/types/simulations/__init__.py
index 318e54366..36672da70 100644
--- a/src/increase/types/simulations/__init__.py
+++ b/src/increase/types/simulations/__init__.py
@@ -2,8 +2,8 @@
from __future__ import annotations
+from .export_create_params import ExportCreateParams as ExportCreateParams
from .program_create_params import ProgramCreateParams as ProgramCreateParams
-from .document_create_params import DocumentCreateParams as DocumentCreateParams
from .card_token_create_params import CardTokenCreateParams as CardTokenCreateParams
from .card_refund_create_params import CardRefundCreateParams as CardRefundCreateParams
from .ach_transfer_return_params import ACHTransferReturnParams as ACHTransferReturnParams
diff --git a/src/increase/types/simulations/document_create_params.py b/src/increase/types/simulations/document_create_params.py
deleted file mode 100644
index 34b6b854e..000000000
--- a/src/increase/types/simulations/document_create_params.py
+++ /dev/null
@@ -1,12 +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__ = ["DocumentCreateParams"]
-
-
-class DocumentCreateParams(TypedDict, total=False):
- account_id: Required[str]
- """The identifier of the Account the tax document is for."""
diff --git a/src/increase/types/simulations/export_create_params.py b/src/increase/types/simulations/export_create_params.py
new file mode 100644
index 000000000..9bb9acb43
--- /dev/null
+++ b/src/increase/types/simulations/export_create_params.py
@@ -0,0 +1,31 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["ExportCreateParams", "Form1099Int"]
+
+
+class ExportCreateParams(TypedDict, total=False):
+ category: Required[Literal["form_1099_int"]]
+ """The type of Export to create.
+
+ - `form_1099_int` - A PDF of an Internal Revenue Service Form 1099-INT.
+ """
+
+ form_1099_int: Form1099Int
+ """Options for the created export.
+
+ Required if `category` is equal to `form_1099_int`.
+ """
+
+
+class Form1099Int(TypedDict, total=False):
+ """Options for the created export.
+
+ Required if `category` is equal to `form_1099_int`.
+ """
+
+ account_id: Required[str]
+ """The identifier of the Account the tax document is for."""
diff --git a/tests/api_resources/simulations/test_documents.py b/tests/api_resources/simulations/test_documents.py
deleted file mode 100644
index 27ff5d598..000000000
--- a/tests/api_resources/simulations/test_documents.py
+++ /dev/null
@@ -1,86 +0,0 @@
-# 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 Document
-
-base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
-
-
-class TestDocuments:
- parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
-
- @parametrize
- def test_method_create(self, client: Increase) -> None:
- document = client.simulations.documents.create(
- account_id="account_in71c4amph0vgo2qllky",
- )
- assert_matches_type(Document, document, path=["response"])
-
- @parametrize
- def test_raw_response_create(self, client: Increase) -> None:
- response = client.simulations.documents.with_raw_response.create(
- account_id="account_in71c4amph0vgo2qllky",
- )
-
- assert response.is_closed is True
- assert response.http_request.headers.get("X-Stainless-Lang") == "python"
- document = response.parse()
- assert_matches_type(Document, document, path=["response"])
-
- @parametrize
- def test_streaming_response_create(self, client: Increase) -> None:
- with client.simulations.documents.with_streaming_response.create(
- account_id="account_in71c4amph0vgo2qllky",
- ) as response:
- assert not response.is_closed
- assert response.http_request.headers.get("X-Stainless-Lang") == "python"
-
- document = response.parse()
- assert_matches_type(Document, document, path=["response"])
-
- assert cast(Any, response.is_closed) is True
-
-
-class TestAsyncDocuments:
- 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:
- document = await async_client.simulations.documents.create(
- account_id="account_in71c4amph0vgo2qllky",
- )
- assert_matches_type(Document, document, path=["response"])
-
- @parametrize
- async def test_raw_response_create(self, async_client: AsyncIncrease) -> None:
- response = await async_client.simulations.documents.with_raw_response.create(
- account_id="account_in71c4amph0vgo2qllky",
- )
-
- assert response.is_closed is True
- assert response.http_request.headers.get("X-Stainless-Lang") == "python"
- document = await response.parse()
- assert_matches_type(Document, document, path=["response"])
-
- @parametrize
- async def test_streaming_response_create(self, async_client: AsyncIncrease) -> None:
- async with async_client.simulations.documents.with_streaming_response.create(
- account_id="account_in71c4amph0vgo2qllky",
- ) as response:
- assert not response.is_closed
- assert response.http_request.headers.get("X-Stainless-Lang") == "python"
-
- document = await response.parse()
- assert_matches_type(Document, document, path=["response"])
-
- assert cast(Any, response.is_closed) is True
diff --git a/tests/api_resources/simulations/test_exports.py b/tests/api_resources/simulations/test_exports.py
new file mode 100644
index 000000000..b36461d02
--- /dev/null
+++ b/tests/api_resources/simulations/test_exports.py
@@ -0,0 +1,102 @@
+# 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 Export
+
+base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
+
+
+class TestExports:
+ parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
+
+ @parametrize
+ def test_method_create(self, client: Increase) -> None:
+ export = client.simulations.exports.create(
+ category="form_1099_int",
+ )
+ assert_matches_type(Export, export, path=["response"])
+
+ @parametrize
+ def test_method_create_with_all_params(self, client: Increase) -> None:
+ export = client.simulations.exports.create(
+ category="form_1099_int",
+ form_1099_int={"account_id": "account_in71c4amph0vgo2qllky"},
+ )
+ assert_matches_type(Export, export, path=["response"])
+
+ @parametrize
+ def test_raw_response_create(self, client: Increase) -> None:
+ response = client.simulations.exports.with_raw_response.create(
+ category="form_1099_int",
+ )
+
+ assert response.is_closed is True
+ assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+ export = response.parse()
+ assert_matches_type(Export, export, path=["response"])
+
+ @parametrize
+ def test_streaming_response_create(self, client: Increase) -> None:
+ with client.simulations.exports.with_streaming_response.create(
+ category="form_1099_int",
+ ) as response:
+ assert not response.is_closed
+ assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+ export = response.parse()
+ assert_matches_type(Export, export, path=["response"])
+
+ assert cast(Any, response.is_closed) is True
+
+
+class TestAsyncExports:
+ 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:
+ export = await async_client.simulations.exports.create(
+ category="form_1099_int",
+ )
+ assert_matches_type(Export, export, path=["response"])
+
+ @parametrize
+ async def test_method_create_with_all_params(self, async_client: AsyncIncrease) -> None:
+ export = await async_client.simulations.exports.create(
+ category="form_1099_int",
+ form_1099_int={"account_id": "account_in71c4amph0vgo2qllky"},
+ )
+ assert_matches_type(Export, export, path=["response"])
+
+ @parametrize
+ async def test_raw_response_create(self, async_client: AsyncIncrease) -> None:
+ response = await async_client.simulations.exports.with_raw_response.create(
+ category="form_1099_int",
+ )
+
+ assert response.is_closed is True
+ assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+ export = await response.parse()
+ assert_matches_type(Export, export, path=["response"])
+
+ @parametrize
+ async def test_streaming_response_create(self, async_client: AsyncIncrease) -> None:
+ async with async_client.simulations.exports.with_streaming_response.create(
+ category="form_1099_int",
+ ) as response:
+ assert not response.is_closed
+ assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+ export = await response.parse()
+ assert_matches_type(Export, export, path=["response"])
+
+ assert cast(Any, response.is_closed) is True
diff --git a/tests/api_resources/test_documents.py b/tests/api_resources/test_documents.py
deleted file mode 100644
index c0d808c7b..000000000
--- a/tests/api_resources/test_documents.py
+++ /dev/null
@@ -1,272 +0,0 @@
-# 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 Document
-from increase._utils import parse_date, parse_datetime
-from increase.pagination import SyncPage, AsyncPage
-
-base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
-
-
-class TestDocuments:
- parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
-
- @parametrize
- def test_method_create(self, client: Increase) -> None:
- document = client.documents.create(
- category="account_verification_letter",
- )
- assert_matches_type(Document, document, path=["response"])
-
- @parametrize
- def test_method_create_with_all_params(self, client: Increase) -> None:
- document = client.documents.create(
- category="account_verification_letter",
- account_verification_letter={
- "account_number_id": "account_number_v18nkfqm6afpsrvy82b2",
- "balance_date": parse_date("2024-12-31"),
- },
- funding_instructions={"account_number_id": "account_number_id"},
- )
- assert_matches_type(Document, document, path=["response"])
-
- @parametrize
- def test_raw_response_create(self, client: Increase) -> None:
- response = client.documents.with_raw_response.create(
- category="account_verification_letter",
- )
-
- assert response.is_closed is True
- assert response.http_request.headers.get("X-Stainless-Lang") == "python"
- document = response.parse()
- assert_matches_type(Document, document, path=["response"])
-
- @parametrize
- def test_streaming_response_create(self, client: Increase) -> None:
- with client.documents.with_streaming_response.create(
- category="account_verification_letter",
- ) as response:
- assert not response.is_closed
- assert response.http_request.headers.get("X-Stainless-Lang") == "python"
-
- document = response.parse()
- assert_matches_type(Document, document, path=["response"])
-
- assert cast(Any, response.is_closed) is True
-
- @parametrize
- def test_method_retrieve(self, client: Increase) -> None:
- document = client.documents.retrieve(
- "document_qjtqc6s4c14ve2q89izm",
- )
- assert_matches_type(Document, document, path=["response"])
-
- @parametrize
- def test_raw_response_retrieve(self, client: Increase) -> None:
- response = client.documents.with_raw_response.retrieve(
- "document_qjtqc6s4c14ve2q89izm",
- )
-
- assert response.is_closed is True
- assert response.http_request.headers.get("X-Stainless-Lang") == "python"
- document = response.parse()
- assert_matches_type(Document, document, path=["response"])
-
- @parametrize
- def test_streaming_response_retrieve(self, client: Increase) -> None:
- with client.documents.with_streaming_response.retrieve(
- "document_qjtqc6s4c14ve2q89izm",
- ) as response:
- assert not response.is_closed
- assert response.http_request.headers.get("X-Stainless-Lang") == "python"
-
- document = response.parse()
- assert_matches_type(Document, document, 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 `document_id` but received ''"):
- client.documents.with_raw_response.retrieve(
- "",
- )
-
- @parametrize
- def test_method_list(self, client: Increase) -> None:
- document = client.documents.list()
- assert_matches_type(SyncPage[Document], document, path=["response"])
-
- @parametrize
- def test_method_list_with_all_params(self, client: Increase) -> None:
- document = client.documents.list(
- category={"in": ["form_1099_int"]},
- 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",
- entity_id="entity_id",
- idempotency_key="x",
- limit=1,
- )
- assert_matches_type(SyncPage[Document], document, path=["response"])
-
- @parametrize
- def test_raw_response_list(self, client: Increase) -> None:
- response = client.documents.with_raw_response.list()
-
- assert response.is_closed is True
- assert response.http_request.headers.get("X-Stainless-Lang") == "python"
- document = response.parse()
- assert_matches_type(SyncPage[Document], document, path=["response"])
-
- @parametrize
- def test_streaming_response_list(self, client: Increase) -> None:
- with client.documents.with_streaming_response.list() as response:
- assert not response.is_closed
- assert response.http_request.headers.get("X-Stainless-Lang") == "python"
-
- document = response.parse()
- assert_matches_type(SyncPage[Document], document, path=["response"])
-
- assert cast(Any, response.is_closed) is True
-
-
-class TestAsyncDocuments:
- 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:
- document = await async_client.documents.create(
- category="account_verification_letter",
- )
- assert_matches_type(Document, document, path=["response"])
-
- @parametrize
- async def test_method_create_with_all_params(self, async_client: AsyncIncrease) -> None:
- document = await async_client.documents.create(
- category="account_verification_letter",
- account_verification_letter={
- "account_number_id": "account_number_v18nkfqm6afpsrvy82b2",
- "balance_date": parse_date("2024-12-31"),
- },
- funding_instructions={"account_number_id": "account_number_id"},
- )
- assert_matches_type(Document, document, path=["response"])
-
- @parametrize
- async def test_raw_response_create(self, async_client: AsyncIncrease) -> None:
- response = await async_client.documents.with_raw_response.create(
- category="account_verification_letter",
- )
-
- assert response.is_closed is True
- assert response.http_request.headers.get("X-Stainless-Lang") == "python"
- document = await response.parse()
- assert_matches_type(Document, document, path=["response"])
-
- @parametrize
- async def test_streaming_response_create(self, async_client: AsyncIncrease) -> None:
- async with async_client.documents.with_streaming_response.create(
- category="account_verification_letter",
- ) as response:
- assert not response.is_closed
- assert response.http_request.headers.get("X-Stainless-Lang") == "python"
-
- document = await response.parse()
- assert_matches_type(Document, document, path=["response"])
-
- assert cast(Any, response.is_closed) is True
-
- @parametrize
- async def test_method_retrieve(self, async_client: AsyncIncrease) -> None:
- document = await async_client.documents.retrieve(
- "document_qjtqc6s4c14ve2q89izm",
- )
- assert_matches_type(Document, document, path=["response"])
-
- @parametrize
- async def test_raw_response_retrieve(self, async_client: AsyncIncrease) -> None:
- response = await async_client.documents.with_raw_response.retrieve(
- "document_qjtqc6s4c14ve2q89izm",
- )
-
- assert response.is_closed is True
- assert response.http_request.headers.get("X-Stainless-Lang") == "python"
- document = await response.parse()
- assert_matches_type(Document, document, path=["response"])
-
- @parametrize
- async def test_streaming_response_retrieve(self, async_client: AsyncIncrease) -> None:
- async with async_client.documents.with_streaming_response.retrieve(
- "document_qjtqc6s4c14ve2q89izm",
- ) as response:
- assert not response.is_closed
- assert response.http_request.headers.get("X-Stainless-Lang") == "python"
-
- document = await response.parse()
- assert_matches_type(Document, document, 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 `document_id` but received ''"):
- await async_client.documents.with_raw_response.retrieve(
- "",
- )
-
- @parametrize
- async def test_method_list(self, async_client: AsyncIncrease) -> None:
- document = await async_client.documents.list()
- assert_matches_type(AsyncPage[Document], document, path=["response"])
-
- @parametrize
- async def test_method_list_with_all_params(self, async_client: AsyncIncrease) -> None:
- document = await async_client.documents.list(
- category={"in": ["form_1099_int"]},
- 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",
- entity_id="entity_id",
- idempotency_key="x",
- limit=1,
- )
- assert_matches_type(AsyncPage[Document], document, path=["response"])
-
- @parametrize
- async def test_raw_response_list(self, async_client: AsyncIncrease) -> None:
- response = await async_client.documents.with_raw_response.list()
-
- assert response.is_closed is True
- assert response.http_request.headers.get("X-Stainless-Lang") == "python"
- document = await response.parse()
- assert_matches_type(AsyncPage[Document], document, path=["response"])
-
- @parametrize
- async def test_streaming_response_list(self, async_client: AsyncIncrease) -> None:
- async with async_client.documents.with_streaming_response.list() as response:
- assert not response.is_closed
- assert response.http_request.headers.get("X-Stainless-Lang") == "python"
-
- document = await response.parse()
- assert_matches_type(AsyncPage[Document], document, path=["response"])
-
- assert cast(Any, response.is_closed) is True
diff --git a/tests/api_resources/test_exports.py b/tests/api_resources/test_exports.py
index 496ac45e1..9ecc5044c 100644
--- a/tests/api_resources/test_exports.py
+++ b/tests/api_resources/test_exports.py
@@ -44,6 +44,10 @@ def test_method_create_with_all_params(self, client: Increase) -> None:
"on_or_before": parse_datetime("2019-12-27T18:11:19.117Z"),
},
},
+ account_verification_letter={
+ "account_number_id": "account_number_id",
+ "balance_date": parse_date("2019-12-27"),
+ },
balance_csv={
"account_id": "account_id",
"created_at": {
@@ -64,6 +68,7 @@ def test_method_create_with_all_params(self, client: Increase) -> None:
},
},
entity_csv={"status": {"in": ["active"]}},
+ funding_instructions={"account_number_id": "account_number_id"},
transaction_csv={
"account_id": "account_in71c4amph0vgo2qllky",
"created_at": {
@@ -213,6 +218,10 @@ async def test_method_create_with_all_params(self, async_client: AsyncIncrease)
"on_or_before": parse_datetime("2019-12-27T18:11:19.117Z"),
},
},
+ account_verification_letter={
+ "account_number_id": "account_number_id",
+ "balance_date": parse_date("2019-12-27"),
+ },
balance_csv={
"account_id": "account_id",
"created_at": {
@@ -233,6 +242,7 @@ async def test_method_create_with_all_params(self, async_client: AsyncIncrease)
},
},
entity_csv={"status": {"in": ["active"]}},
+ funding_instructions={"account_number_id": "account_number_id"},
transaction_csv={
"account_id": "account_in71c4amph0vgo2qllky",
"created_at": {