diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index eefc48ef..f93be0ea 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -61,14 +61,18 @@ jobs: run: rye build - name: Get GitHub OIDC Token - if: github.repository == 'stainless-sdks/whopsdk-python' + if: |- + github.repository == 'stainless-sdks/whopsdk-python' && + !startsWith(github.ref, 'refs/heads/stl/') id: github-oidc uses: actions/github-script@v8 with: script: core.setOutput('github_token', await core.getIDToken()); - name: Upload tarball - if: github.repository == 'stainless-sdks/whopsdk-python' + if: |- + github.repository == 'stainless-sdks/whopsdk-python' && + !startsWith(github.ref, 'refs/heads/stl/') env: URL: https://pkg.stainless.com/s AUTH: ${{ steps.github-oidc.outputs.github_token }} diff --git a/.release-please-manifest.json b/.release-please-manifest.json index 34ac707c..3d2ac0bd 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.0.30" + ".": "0.1.0" } \ No newline at end of file diff --git a/.stats.yml b/.stats.yml index f91f6ee2..cbc67135 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ -configured_endpoints: 173 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/frostedinc%2Fwhopsdk-cc6caefebc5d0c5b09a38a2ca3de9b07a8af8017a45a3a8ae4687eea30e5df93.yml -openapi_spec_hash: 384c511adb0c53319ac3ece08843f485 -config_hash: 8ac153ea57fa6460b13cded3f7c9c7a6 +configured_endpoints: 176 +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/frostedinc%2Fwhopsdk-f49331e3fb23d1041f941c72c6ee9924dfa47634889ed5209244207c8ea0586e.yml +openapi_spec_hash: 93d6cef1312ed0cbe6b2b6616c535ebf +config_hash: 71004ac2f2a6283ca55db1065c47e5f6 diff --git a/CHANGELOG.md b/CHANGELOG.md index dd2e1246..eb73b72b 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,32 @@ # Changelog +## 0.1.0 (2026-03-10) + +Full Changelog: [v0.0.30...v0.1.0](https://github.com/whopio/whopsdk-python/compare/v0.0.30...v0.1.0) + +### Features + +* **api:** api update ([99175a1](https://github.com/whopio/whopsdk-python/commit/99175a149a05f6c54b225447a163b958af8ae61c)) +* **api:** api update ([fe17d66](https://github.com/whopio/whopsdk-python/commit/fe17d66f82035b4e58f474bfd136bf78114aaeab)) +* **api:** api update ([2ee7fe7](https://github.com/whopio/whopsdk-python/commit/2ee7fe71e837e7f91ed021b58217abaf89782879)) +* **api:** api update ([260853e](https://github.com/whopio/whopsdk-python/commit/260853e5ec3e85481b25da49ec4252b8b773e81a)) +* **api:** api update ([dcef405](https://github.com/whopio/whopsdk-python/commit/dcef4059c4ce8e9fdffa7d2aba850f325c53fb57)) +* **api:** api update ([abc268f](https://github.com/whopio/whopsdk-python/commit/abc268f2c7a2d59ed01e6fd595aaf3559b831302)) +* **api:** api update ([2f4cd94](https://github.com/whopio/whopsdk-python/commit/2f4cd94cdca591d743dd905f9b325d25fe45acb8)) +* **api:** api update ([ad1d5b7](https://github.com/whopio/whopsdk-python/commit/ad1d5b78546c5efd4214e22c42aa7a64227bc34c)) +* **api:** api update ([c2f142d](https://github.com/whopio/whopsdk-python/commit/c2f142d7aebad6ec2b140d70a8b93aa3205290ec)) +* **api:** api update ([d62a4b7](https://github.com/whopio/whopsdk-python/commit/d62a4b7961c1264d9c4055a026238a72822b8b19)) +* **api:** api update ([c60ab1e](https://github.com/whopio/whopsdk-python/commit/c60ab1e6568cef6910ec61773887c8b9546c52d4)) +* **api:** api update ([020c181](https://github.com/whopio/whopsdk-python/commit/020c181cf53f7811401fe01d4382fe490e6e5398)) +* **api:** manual updates ([b162886](https://github.com/whopio/whopsdk-python/commit/b1628865df13ae4d703571e46e738405652ad150)) + + +### Chores + +* **ci:** skip uploading artifacts on stainless-internal branches ([04a3a6d](https://github.com/whopio/whopsdk-python/commit/04a3a6d8263e34b42b476380846af4d4f31deedd)) +* **docs:** add missing descriptions ([beeb9ef](https://github.com/whopio/whopsdk-python/commit/beeb9efca946b1bc2e565239ac96d3d2d8642b6f)) +* **tests:** update webhook tests ([f740d3c](https://github.com/whopio/whopsdk-python/commit/f740d3c6d32e332ecea2ec902e9903c36055443e)) + ## 0.0.30 (2026-02-26) Full Changelog: [v0.0.29...v0.0.30](https://github.com/whopio/whopsdk-python/compare/v0.0.29...v0.0.30) diff --git a/api.md b/api.md index 679a9af1..cb3e0091 100644 --- a/api.md +++ b/api.md @@ -121,7 +121,7 @@ Methods: Types: ```python -from whop_sdk.types import CompanyListResponse +from whop_sdk.types import SocialLinkWebsites, CompanyListResponse ``` Methods: @@ -268,6 +268,7 @@ Methods: - client.memberships.retrieve(id) -> Membership - client.memberships.update(id, \*\*params) -> Membership - client.memberships.list(\*\*params) -> SyncCursorPage[MembershipListResponse] +- client.memberships.add_free_days(id, \*\*params) -> Membership - client.memberships.cancel(id, \*\*params) -> Membership - client.memberships.pause(id, \*\*params) -> Membership - client.memberships.resume(id) -> Membership @@ -278,13 +279,20 @@ Methods: Types: ```python -from whop_sdk.types import AuthorizedUserRetrieveResponse, AuthorizedUserListResponse +from whop_sdk.types import ( + AuthorizedUserCreateResponse, + AuthorizedUserRetrieveResponse, + AuthorizedUserListResponse, + AuthorizedUserDeleteResponse, +) ``` Methods: +- client.authorized_users.create(\*\*params) -> AuthorizedUserCreateResponse - client.authorized_users.retrieve(id) -> AuthorizedUserRetrieveResponse - client.authorized_users.list(\*\*params) -> SyncCursorPage[AuthorizedUserListResponse] +- client.authorized_users.delete(id, \*\*params) -> AuthorizedUserDeleteResponse # AppBuilds @@ -382,6 +390,7 @@ from whop_sdk.types import ( BillingReasons, CardBrands, PaymentMethodTypes, + ReceiptTaxBehavior, PaymentListResponse, PaymentListFeesResponse, ) diff --git a/pyproject.toml b/pyproject.toml index 80fe5263..9279b720 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "whop-sdk" -version = "0.0.30" +version = "0.1.0" description = "The official Python library for the Whop API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/whop_sdk/_client.py b/src/whop_sdk/_client.py index 65a4f492..ae5d5c9f 100644 --- a/src/whop_sdk/_client.py +++ b/src/whop_sdk/_client.py @@ -215,300 +215,350 @@ def __init__( @cached_property def apps(self) -> AppsResource: + """Apps""" from .resources.apps import AppsResource return AppsResource(self) @cached_property def invoices(self) -> InvoicesResource: + """Invoices""" from .resources.invoices import InvoicesResource return InvoicesResource(self) @cached_property def course_lesson_interactions(self) -> CourseLessonInteractionsResource: + """Course lesson interactions""" from .resources.course_lesson_interactions import CourseLessonInteractionsResource return CourseLessonInteractionsResource(self) @cached_property def products(self) -> ProductsResource: + """Products""" from .resources.products import ProductsResource return ProductsResource(self) @cached_property def companies(self) -> CompaniesResource: + """Companies""" from .resources.companies import CompaniesResource return CompaniesResource(self) @cached_property def webhooks(self) -> WebhooksResource: + """Webhooks""" from .resources.webhooks import WebhooksResource return WebhooksResource(self) @cached_property def plans(self) -> PlansResource: + """Plans""" from .resources.plans import PlansResource return PlansResource(self) @cached_property def entries(self) -> EntriesResource: + """Entries""" from .resources.entries import EntriesResource return EntriesResource(self) @cached_property def forum_posts(self) -> ForumPostsResource: + """Forum posts""" from .resources.forum_posts import ForumPostsResource return ForumPostsResource(self) @cached_property def transfers(self) -> TransfersResource: + """Transfers""" from .resources.transfers import TransfersResource return TransfersResource(self) @cached_property def ledger_accounts(self) -> LedgerAccountsResource: + """Ledger accounts""" from .resources.ledger_accounts import LedgerAccountsResource return LedgerAccountsResource(self) @cached_property def memberships(self) -> MembershipsResource: + """Memberships""" from .resources.memberships import MembershipsResource return MembershipsResource(self) @cached_property def authorized_users(self) -> AuthorizedUsersResource: + """Authorized users""" from .resources.authorized_users import AuthorizedUsersResource return AuthorizedUsersResource(self) @cached_property def app_builds(self) -> AppBuildsResource: + """App builds""" from .resources.app_builds import AppBuildsResource return AppBuildsResource(self) @cached_property def shipments(self) -> ShipmentsResource: + """Shipments""" from .resources.shipments import ShipmentsResource return ShipmentsResource(self) @cached_property def checkout_configurations(self) -> CheckoutConfigurationsResource: + """Checkout configurations""" from .resources.checkout_configurations import CheckoutConfigurationsResource return CheckoutConfigurationsResource(self) @cached_property def messages(self) -> MessagesResource: + """Messages""" from .resources.messages import MessagesResource return MessagesResource(self) @cached_property def chat_channels(self) -> ChatChannelsResource: + """Chat channels""" from .resources.chat_channels import ChatChannelsResource return ChatChannelsResource(self) @cached_property def users(self) -> UsersResource: + """Users""" from .resources.users import UsersResource return UsersResource(self) @cached_property def payments(self) -> PaymentsResource: + """Payments""" from .resources.payments import PaymentsResource return PaymentsResource(self) @cached_property def support_channels(self) -> SupportChannelsResource: + """Support channels""" from .resources.support_channels import SupportChannelsResource return SupportChannelsResource(self) @cached_property def experiences(self) -> ExperiencesResource: + """Experiences""" from .resources.experiences import ExperiencesResource return ExperiencesResource(self) @cached_property def reactions(self) -> ReactionsResource: + """Reactions""" from .resources.reactions import ReactionsResource return ReactionsResource(self) @cached_property def members(self) -> MembersResource: + """Members""" from .resources.members import MembersResource return MembersResource(self) @cached_property def forums(self) -> ForumsResource: + """Forums""" from .resources.forums import ForumsResource return ForumsResource(self) @cached_property def promo_codes(self) -> PromoCodesResource: + """Promo codes""" from .resources.promo_codes import PromoCodesResource return PromoCodesResource(self) @cached_property def courses(self) -> CoursesResource: + """Courses""" from .resources.courses import CoursesResource return CoursesResource(self) @cached_property def course_chapters(self) -> CourseChaptersResource: + """Course chapters""" from .resources.course_chapters import CourseChaptersResource return CourseChaptersResource(self) @cached_property def course_lessons(self) -> CourseLessonsResource: + """Course lessons""" from .resources.course_lessons import CourseLessonsResource return CourseLessonsResource(self) @cached_property def reviews(self) -> ReviewsResource: + """Reviews""" from .resources.reviews import ReviewsResource return ReviewsResource(self) @cached_property def course_students(self) -> CourseStudentsResource: + """Course students""" from .resources.course_students import CourseStudentsResource return CourseStudentsResource(self) @cached_property def access_tokens(self) -> AccessTokensResource: + """Access tokens""" from .resources.access_tokens import AccessTokensResource return AccessTokensResource(self) @cached_property def notifications(self) -> NotificationsResource: + """Notifications""" from .resources.notifications import NotificationsResource return NotificationsResource(self) @cached_property def disputes(self) -> DisputesResource: + """Disputes""" from .resources.disputes import DisputesResource return DisputesResource(self) @cached_property def refunds(self) -> RefundsResource: + """Refunds""" from .resources.refunds import RefundsResource return RefundsResource(self) @cached_property def withdrawals(self) -> WithdrawalsResource: + """Withdrawals""" from .resources.withdrawals import WithdrawalsResource return WithdrawalsResource(self) @cached_property def account_links(self) -> AccountLinksResource: + """Account links""" from .resources.account_links import AccountLinksResource return AccountLinksResource(self) @cached_property def setup_intents(self) -> SetupIntentsResource: + """Setup intents""" from .resources.setup_intents import SetupIntentsResource return SetupIntentsResource(self) @cached_property def payment_methods(self) -> PaymentMethodsResource: + """Payment methods""" from .resources.payment_methods import PaymentMethodsResource return PaymentMethodsResource(self) @cached_property def fee_markups(self) -> FeeMarkupsResource: + """Fee markups""" from .resources.fee_markups import FeeMarkupsResource return FeeMarkupsResource(self) @cached_property def payout_methods(self) -> PayoutMethodsResource: + """Payout methods""" from .resources.payout_methods import PayoutMethodsResource return PayoutMethodsResource(self) @cached_property def verifications(self) -> VerificationsResource: + """Verifications""" from .resources.verifications import VerificationsResource return VerificationsResource(self) @cached_property def leads(self) -> LeadsResource: + """Leads""" from .resources.leads import LeadsResource return LeadsResource(self) @cached_property def topups(self) -> TopupsResource: + """Topups""" from .resources.topups import TopupsResource return TopupsResource(self) @cached_property def files(self) -> FilesResource: + """Files""" from .resources.files import FilesResource return FilesResource(self) @cached_property def company_token_transactions(self) -> CompanyTokenTransactionsResource: + """Company token transactions""" from .resources.company_token_transactions import CompanyTokenTransactionsResource return CompanyTokenTransactionsResource(self) @cached_property def dm_members(self) -> DmMembersResource: + """Dm members""" from .resources.dm_members import DmMembersResource return DmMembersResource(self) @cached_property def ai_chats(self) -> AIChatsResource: + """Ai chats""" from .resources.ai_chats import AIChatsResource return AIChatsResource(self) @cached_property def dm_channels(self) -> DmChannelsResource: + """Dm channels""" from .resources.dm_channels import DmChannelsResource return DmChannelsResource(self) @cached_property def dispute_alerts(self) -> DisputeAlertsResource: + """Dispute alerts""" from .resources.dispute_alerts import DisputeAlertsResource return DisputeAlertsResource(self) @@ -703,300 +753,350 @@ def __init__( @cached_property def apps(self) -> AsyncAppsResource: + """Apps""" from .resources.apps import AsyncAppsResource return AsyncAppsResource(self) @cached_property def invoices(self) -> AsyncInvoicesResource: + """Invoices""" from .resources.invoices import AsyncInvoicesResource return AsyncInvoicesResource(self) @cached_property def course_lesson_interactions(self) -> AsyncCourseLessonInteractionsResource: + """Course lesson interactions""" from .resources.course_lesson_interactions import AsyncCourseLessonInteractionsResource return AsyncCourseLessonInteractionsResource(self) @cached_property def products(self) -> AsyncProductsResource: + """Products""" from .resources.products import AsyncProductsResource return AsyncProductsResource(self) @cached_property def companies(self) -> AsyncCompaniesResource: + """Companies""" from .resources.companies import AsyncCompaniesResource return AsyncCompaniesResource(self) @cached_property def webhooks(self) -> AsyncWebhooksResource: + """Webhooks""" from .resources.webhooks import AsyncWebhooksResource return AsyncWebhooksResource(self) @cached_property def plans(self) -> AsyncPlansResource: + """Plans""" from .resources.plans import AsyncPlansResource return AsyncPlansResource(self) @cached_property def entries(self) -> AsyncEntriesResource: + """Entries""" from .resources.entries import AsyncEntriesResource return AsyncEntriesResource(self) @cached_property def forum_posts(self) -> AsyncForumPostsResource: + """Forum posts""" from .resources.forum_posts import AsyncForumPostsResource return AsyncForumPostsResource(self) @cached_property def transfers(self) -> AsyncTransfersResource: + """Transfers""" from .resources.transfers import AsyncTransfersResource return AsyncTransfersResource(self) @cached_property def ledger_accounts(self) -> AsyncLedgerAccountsResource: + """Ledger accounts""" from .resources.ledger_accounts import AsyncLedgerAccountsResource return AsyncLedgerAccountsResource(self) @cached_property def memberships(self) -> AsyncMembershipsResource: + """Memberships""" from .resources.memberships import AsyncMembershipsResource return AsyncMembershipsResource(self) @cached_property def authorized_users(self) -> AsyncAuthorizedUsersResource: + """Authorized users""" from .resources.authorized_users import AsyncAuthorizedUsersResource return AsyncAuthorizedUsersResource(self) @cached_property def app_builds(self) -> AsyncAppBuildsResource: + """App builds""" from .resources.app_builds import AsyncAppBuildsResource return AsyncAppBuildsResource(self) @cached_property def shipments(self) -> AsyncShipmentsResource: + """Shipments""" from .resources.shipments import AsyncShipmentsResource return AsyncShipmentsResource(self) @cached_property def checkout_configurations(self) -> AsyncCheckoutConfigurationsResource: + """Checkout configurations""" from .resources.checkout_configurations import AsyncCheckoutConfigurationsResource return AsyncCheckoutConfigurationsResource(self) @cached_property def messages(self) -> AsyncMessagesResource: + """Messages""" from .resources.messages import AsyncMessagesResource return AsyncMessagesResource(self) @cached_property def chat_channels(self) -> AsyncChatChannelsResource: + """Chat channels""" from .resources.chat_channels import AsyncChatChannelsResource return AsyncChatChannelsResource(self) @cached_property def users(self) -> AsyncUsersResource: + """Users""" from .resources.users import AsyncUsersResource return AsyncUsersResource(self) @cached_property def payments(self) -> AsyncPaymentsResource: + """Payments""" from .resources.payments import AsyncPaymentsResource return AsyncPaymentsResource(self) @cached_property def support_channels(self) -> AsyncSupportChannelsResource: + """Support channels""" from .resources.support_channels import AsyncSupportChannelsResource return AsyncSupportChannelsResource(self) @cached_property def experiences(self) -> AsyncExperiencesResource: + """Experiences""" from .resources.experiences import AsyncExperiencesResource return AsyncExperiencesResource(self) @cached_property def reactions(self) -> AsyncReactionsResource: + """Reactions""" from .resources.reactions import AsyncReactionsResource return AsyncReactionsResource(self) @cached_property def members(self) -> AsyncMembersResource: + """Members""" from .resources.members import AsyncMembersResource return AsyncMembersResource(self) @cached_property def forums(self) -> AsyncForumsResource: + """Forums""" from .resources.forums import AsyncForumsResource return AsyncForumsResource(self) @cached_property def promo_codes(self) -> AsyncPromoCodesResource: + """Promo codes""" from .resources.promo_codes import AsyncPromoCodesResource return AsyncPromoCodesResource(self) @cached_property def courses(self) -> AsyncCoursesResource: + """Courses""" from .resources.courses import AsyncCoursesResource return AsyncCoursesResource(self) @cached_property def course_chapters(self) -> AsyncCourseChaptersResource: + """Course chapters""" from .resources.course_chapters import AsyncCourseChaptersResource return AsyncCourseChaptersResource(self) @cached_property def course_lessons(self) -> AsyncCourseLessonsResource: + """Course lessons""" from .resources.course_lessons import AsyncCourseLessonsResource return AsyncCourseLessonsResource(self) @cached_property def reviews(self) -> AsyncReviewsResource: + """Reviews""" from .resources.reviews import AsyncReviewsResource return AsyncReviewsResource(self) @cached_property def course_students(self) -> AsyncCourseStudentsResource: + """Course students""" from .resources.course_students import AsyncCourseStudentsResource return AsyncCourseStudentsResource(self) @cached_property def access_tokens(self) -> AsyncAccessTokensResource: + """Access tokens""" from .resources.access_tokens import AsyncAccessTokensResource return AsyncAccessTokensResource(self) @cached_property def notifications(self) -> AsyncNotificationsResource: + """Notifications""" from .resources.notifications import AsyncNotificationsResource return AsyncNotificationsResource(self) @cached_property def disputes(self) -> AsyncDisputesResource: + """Disputes""" from .resources.disputes import AsyncDisputesResource return AsyncDisputesResource(self) @cached_property def refunds(self) -> AsyncRefundsResource: + """Refunds""" from .resources.refunds import AsyncRefundsResource return AsyncRefundsResource(self) @cached_property def withdrawals(self) -> AsyncWithdrawalsResource: + """Withdrawals""" from .resources.withdrawals import AsyncWithdrawalsResource return AsyncWithdrawalsResource(self) @cached_property def account_links(self) -> AsyncAccountLinksResource: + """Account links""" from .resources.account_links import AsyncAccountLinksResource return AsyncAccountLinksResource(self) @cached_property def setup_intents(self) -> AsyncSetupIntentsResource: + """Setup intents""" from .resources.setup_intents import AsyncSetupIntentsResource return AsyncSetupIntentsResource(self) @cached_property def payment_methods(self) -> AsyncPaymentMethodsResource: + """Payment methods""" from .resources.payment_methods import AsyncPaymentMethodsResource return AsyncPaymentMethodsResource(self) @cached_property def fee_markups(self) -> AsyncFeeMarkupsResource: + """Fee markups""" from .resources.fee_markups import AsyncFeeMarkupsResource return AsyncFeeMarkupsResource(self) @cached_property def payout_methods(self) -> AsyncPayoutMethodsResource: + """Payout methods""" from .resources.payout_methods import AsyncPayoutMethodsResource return AsyncPayoutMethodsResource(self) @cached_property def verifications(self) -> AsyncVerificationsResource: + """Verifications""" from .resources.verifications import AsyncVerificationsResource return AsyncVerificationsResource(self) @cached_property def leads(self) -> AsyncLeadsResource: + """Leads""" from .resources.leads import AsyncLeadsResource return AsyncLeadsResource(self) @cached_property def topups(self) -> AsyncTopupsResource: + """Topups""" from .resources.topups import AsyncTopupsResource return AsyncTopupsResource(self) @cached_property def files(self) -> AsyncFilesResource: + """Files""" from .resources.files import AsyncFilesResource return AsyncFilesResource(self) @cached_property def company_token_transactions(self) -> AsyncCompanyTokenTransactionsResource: + """Company token transactions""" from .resources.company_token_transactions import AsyncCompanyTokenTransactionsResource return AsyncCompanyTokenTransactionsResource(self) @cached_property def dm_members(self) -> AsyncDmMembersResource: + """Dm members""" from .resources.dm_members import AsyncDmMembersResource return AsyncDmMembersResource(self) @cached_property def ai_chats(self) -> AsyncAIChatsResource: + """Ai chats""" from .resources.ai_chats import AsyncAIChatsResource return AsyncAIChatsResource(self) @cached_property def dm_channels(self) -> AsyncDmChannelsResource: + """Dm channels""" from .resources.dm_channels import AsyncDmChannelsResource return AsyncDmChannelsResource(self) @cached_property def dispute_alerts(self) -> AsyncDisputeAlertsResource: + """Dispute alerts""" from .resources.dispute_alerts import AsyncDisputeAlertsResource return AsyncDisputeAlertsResource(self) @@ -1127,300 +1227,350 @@ def __init__(self, client: Whop) -> None: @cached_property def apps(self) -> apps.AppsResourceWithRawResponse: + """Apps""" from .resources.apps import AppsResourceWithRawResponse return AppsResourceWithRawResponse(self._client.apps) @cached_property def invoices(self) -> invoices.InvoicesResourceWithRawResponse: + """Invoices""" from .resources.invoices import InvoicesResourceWithRawResponse return InvoicesResourceWithRawResponse(self._client.invoices) @cached_property def course_lesson_interactions(self) -> course_lesson_interactions.CourseLessonInteractionsResourceWithRawResponse: + """Course lesson interactions""" from .resources.course_lesson_interactions import CourseLessonInteractionsResourceWithRawResponse return CourseLessonInteractionsResourceWithRawResponse(self._client.course_lesson_interactions) @cached_property def products(self) -> products.ProductsResourceWithRawResponse: + """Products""" from .resources.products import ProductsResourceWithRawResponse return ProductsResourceWithRawResponse(self._client.products) @cached_property def companies(self) -> companies.CompaniesResourceWithRawResponse: + """Companies""" from .resources.companies import CompaniesResourceWithRawResponse return CompaniesResourceWithRawResponse(self._client.companies) @cached_property def webhooks(self) -> webhooks.WebhooksResourceWithRawResponse: + """Webhooks""" from .resources.webhooks import WebhooksResourceWithRawResponse return WebhooksResourceWithRawResponse(self._client.webhooks) @cached_property def plans(self) -> plans.PlansResourceWithRawResponse: + """Plans""" from .resources.plans import PlansResourceWithRawResponse return PlansResourceWithRawResponse(self._client.plans) @cached_property def entries(self) -> entries.EntriesResourceWithRawResponse: + """Entries""" from .resources.entries import EntriesResourceWithRawResponse return EntriesResourceWithRawResponse(self._client.entries) @cached_property def forum_posts(self) -> forum_posts.ForumPostsResourceWithRawResponse: + """Forum posts""" from .resources.forum_posts import ForumPostsResourceWithRawResponse return ForumPostsResourceWithRawResponse(self._client.forum_posts) @cached_property def transfers(self) -> transfers.TransfersResourceWithRawResponse: + """Transfers""" from .resources.transfers import TransfersResourceWithRawResponse return TransfersResourceWithRawResponse(self._client.transfers) @cached_property def ledger_accounts(self) -> ledger_accounts.LedgerAccountsResourceWithRawResponse: + """Ledger accounts""" from .resources.ledger_accounts import LedgerAccountsResourceWithRawResponse return LedgerAccountsResourceWithRawResponse(self._client.ledger_accounts) @cached_property def memberships(self) -> memberships.MembershipsResourceWithRawResponse: + """Memberships""" from .resources.memberships import MembershipsResourceWithRawResponse return MembershipsResourceWithRawResponse(self._client.memberships) @cached_property def authorized_users(self) -> authorized_users.AuthorizedUsersResourceWithRawResponse: + """Authorized users""" from .resources.authorized_users import AuthorizedUsersResourceWithRawResponse return AuthorizedUsersResourceWithRawResponse(self._client.authorized_users) @cached_property def app_builds(self) -> app_builds.AppBuildsResourceWithRawResponse: + """App builds""" from .resources.app_builds import AppBuildsResourceWithRawResponse return AppBuildsResourceWithRawResponse(self._client.app_builds) @cached_property def shipments(self) -> shipments.ShipmentsResourceWithRawResponse: + """Shipments""" from .resources.shipments import ShipmentsResourceWithRawResponse return ShipmentsResourceWithRawResponse(self._client.shipments) @cached_property def checkout_configurations(self) -> checkout_configurations.CheckoutConfigurationsResourceWithRawResponse: + """Checkout configurations""" from .resources.checkout_configurations import CheckoutConfigurationsResourceWithRawResponse return CheckoutConfigurationsResourceWithRawResponse(self._client.checkout_configurations) @cached_property def messages(self) -> messages.MessagesResourceWithRawResponse: + """Messages""" from .resources.messages import MessagesResourceWithRawResponse return MessagesResourceWithRawResponse(self._client.messages) @cached_property def chat_channels(self) -> chat_channels.ChatChannelsResourceWithRawResponse: + """Chat channels""" from .resources.chat_channels import ChatChannelsResourceWithRawResponse return ChatChannelsResourceWithRawResponse(self._client.chat_channels) @cached_property def users(self) -> users.UsersResourceWithRawResponse: + """Users""" from .resources.users import UsersResourceWithRawResponse return UsersResourceWithRawResponse(self._client.users) @cached_property def payments(self) -> payments.PaymentsResourceWithRawResponse: + """Payments""" from .resources.payments import PaymentsResourceWithRawResponse return PaymentsResourceWithRawResponse(self._client.payments) @cached_property def support_channels(self) -> support_channels.SupportChannelsResourceWithRawResponse: + """Support channels""" from .resources.support_channels import SupportChannelsResourceWithRawResponse return SupportChannelsResourceWithRawResponse(self._client.support_channels) @cached_property def experiences(self) -> experiences.ExperiencesResourceWithRawResponse: + """Experiences""" from .resources.experiences import ExperiencesResourceWithRawResponse return ExperiencesResourceWithRawResponse(self._client.experiences) @cached_property def reactions(self) -> reactions.ReactionsResourceWithRawResponse: + """Reactions""" from .resources.reactions import ReactionsResourceWithRawResponse return ReactionsResourceWithRawResponse(self._client.reactions) @cached_property def members(self) -> members.MembersResourceWithRawResponse: + """Members""" from .resources.members import MembersResourceWithRawResponse return MembersResourceWithRawResponse(self._client.members) @cached_property def forums(self) -> forums.ForumsResourceWithRawResponse: + """Forums""" from .resources.forums import ForumsResourceWithRawResponse return ForumsResourceWithRawResponse(self._client.forums) @cached_property def promo_codes(self) -> promo_codes.PromoCodesResourceWithRawResponse: + """Promo codes""" from .resources.promo_codes import PromoCodesResourceWithRawResponse return PromoCodesResourceWithRawResponse(self._client.promo_codes) @cached_property def courses(self) -> courses.CoursesResourceWithRawResponse: + """Courses""" from .resources.courses import CoursesResourceWithRawResponse return CoursesResourceWithRawResponse(self._client.courses) @cached_property def course_chapters(self) -> course_chapters.CourseChaptersResourceWithRawResponse: + """Course chapters""" from .resources.course_chapters import CourseChaptersResourceWithRawResponse return CourseChaptersResourceWithRawResponse(self._client.course_chapters) @cached_property def course_lessons(self) -> course_lessons.CourseLessonsResourceWithRawResponse: + """Course lessons""" from .resources.course_lessons import CourseLessonsResourceWithRawResponse return CourseLessonsResourceWithRawResponse(self._client.course_lessons) @cached_property def reviews(self) -> reviews.ReviewsResourceWithRawResponse: + """Reviews""" from .resources.reviews import ReviewsResourceWithRawResponse return ReviewsResourceWithRawResponse(self._client.reviews) @cached_property def course_students(self) -> course_students.CourseStudentsResourceWithRawResponse: + """Course students""" from .resources.course_students import CourseStudentsResourceWithRawResponse return CourseStudentsResourceWithRawResponse(self._client.course_students) @cached_property def access_tokens(self) -> access_tokens.AccessTokensResourceWithRawResponse: + """Access tokens""" from .resources.access_tokens import AccessTokensResourceWithRawResponse return AccessTokensResourceWithRawResponse(self._client.access_tokens) @cached_property def notifications(self) -> notifications.NotificationsResourceWithRawResponse: + """Notifications""" from .resources.notifications import NotificationsResourceWithRawResponse return NotificationsResourceWithRawResponse(self._client.notifications) @cached_property def disputes(self) -> disputes.DisputesResourceWithRawResponse: + """Disputes""" from .resources.disputes import DisputesResourceWithRawResponse return DisputesResourceWithRawResponse(self._client.disputes) @cached_property def refunds(self) -> refunds.RefundsResourceWithRawResponse: + """Refunds""" from .resources.refunds import RefundsResourceWithRawResponse return RefundsResourceWithRawResponse(self._client.refunds) @cached_property def withdrawals(self) -> withdrawals.WithdrawalsResourceWithRawResponse: + """Withdrawals""" from .resources.withdrawals import WithdrawalsResourceWithRawResponse return WithdrawalsResourceWithRawResponse(self._client.withdrawals) @cached_property def account_links(self) -> account_links.AccountLinksResourceWithRawResponse: + """Account links""" from .resources.account_links import AccountLinksResourceWithRawResponse return AccountLinksResourceWithRawResponse(self._client.account_links) @cached_property def setup_intents(self) -> setup_intents.SetupIntentsResourceWithRawResponse: + """Setup intents""" from .resources.setup_intents import SetupIntentsResourceWithRawResponse return SetupIntentsResourceWithRawResponse(self._client.setup_intents) @cached_property def payment_methods(self) -> payment_methods.PaymentMethodsResourceWithRawResponse: + """Payment methods""" from .resources.payment_methods import PaymentMethodsResourceWithRawResponse return PaymentMethodsResourceWithRawResponse(self._client.payment_methods) @cached_property def fee_markups(self) -> fee_markups.FeeMarkupsResourceWithRawResponse: + """Fee markups""" from .resources.fee_markups import FeeMarkupsResourceWithRawResponse return FeeMarkupsResourceWithRawResponse(self._client.fee_markups) @cached_property def payout_methods(self) -> payout_methods.PayoutMethodsResourceWithRawResponse: + """Payout methods""" from .resources.payout_methods import PayoutMethodsResourceWithRawResponse return PayoutMethodsResourceWithRawResponse(self._client.payout_methods) @cached_property def verifications(self) -> verifications.VerificationsResourceWithRawResponse: + """Verifications""" from .resources.verifications import VerificationsResourceWithRawResponse return VerificationsResourceWithRawResponse(self._client.verifications) @cached_property def leads(self) -> leads.LeadsResourceWithRawResponse: + """Leads""" from .resources.leads import LeadsResourceWithRawResponse return LeadsResourceWithRawResponse(self._client.leads) @cached_property def topups(self) -> topups.TopupsResourceWithRawResponse: + """Topups""" from .resources.topups import TopupsResourceWithRawResponse return TopupsResourceWithRawResponse(self._client.topups) @cached_property def files(self) -> files.FilesResourceWithRawResponse: + """Files""" from .resources.files import FilesResourceWithRawResponse return FilesResourceWithRawResponse(self._client.files) @cached_property def company_token_transactions(self) -> company_token_transactions.CompanyTokenTransactionsResourceWithRawResponse: + """Company token transactions""" from .resources.company_token_transactions import CompanyTokenTransactionsResourceWithRawResponse return CompanyTokenTransactionsResourceWithRawResponse(self._client.company_token_transactions) @cached_property def dm_members(self) -> dm_members.DmMembersResourceWithRawResponse: + """Dm members""" from .resources.dm_members import DmMembersResourceWithRawResponse return DmMembersResourceWithRawResponse(self._client.dm_members) @cached_property def ai_chats(self) -> ai_chats.AIChatsResourceWithRawResponse: + """Ai chats""" from .resources.ai_chats import AIChatsResourceWithRawResponse return AIChatsResourceWithRawResponse(self._client.ai_chats) @cached_property def dm_channels(self) -> dm_channels.DmChannelsResourceWithRawResponse: + """Dm channels""" from .resources.dm_channels import DmChannelsResourceWithRawResponse return DmChannelsResourceWithRawResponse(self._client.dm_channels) @cached_property def dispute_alerts(self) -> dispute_alerts.DisputeAlertsResourceWithRawResponse: + """Dispute alerts""" from .resources.dispute_alerts import DisputeAlertsResourceWithRawResponse return DisputeAlertsResourceWithRawResponse(self._client.dispute_alerts) @@ -1434,12 +1584,14 @@ def __init__(self, client: AsyncWhop) -> None: @cached_property def apps(self) -> apps.AsyncAppsResourceWithRawResponse: + """Apps""" from .resources.apps import AsyncAppsResourceWithRawResponse return AsyncAppsResourceWithRawResponse(self._client.apps) @cached_property def invoices(self) -> invoices.AsyncInvoicesResourceWithRawResponse: + """Invoices""" from .resources.invoices import AsyncInvoicesResourceWithRawResponse return AsyncInvoicesResourceWithRawResponse(self._client.invoices) @@ -1448,258 +1600,301 @@ def invoices(self) -> invoices.AsyncInvoicesResourceWithRawResponse: def course_lesson_interactions( self, ) -> course_lesson_interactions.AsyncCourseLessonInteractionsResourceWithRawResponse: + """Course lesson interactions""" from .resources.course_lesson_interactions import AsyncCourseLessonInteractionsResourceWithRawResponse return AsyncCourseLessonInteractionsResourceWithRawResponse(self._client.course_lesson_interactions) @cached_property def products(self) -> products.AsyncProductsResourceWithRawResponse: + """Products""" from .resources.products import AsyncProductsResourceWithRawResponse return AsyncProductsResourceWithRawResponse(self._client.products) @cached_property def companies(self) -> companies.AsyncCompaniesResourceWithRawResponse: + """Companies""" from .resources.companies import AsyncCompaniesResourceWithRawResponse return AsyncCompaniesResourceWithRawResponse(self._client.companies) @cached_property def webhooks(self) -> webhooks.AsyncWebhooksResourceWithRawResponse: + """Webhooks""" from .resources.webhooks import AsyncWebhooksResourceWithRawResponse return AsyncWebhooksResourceWithRawResponse(self._client.webhooks) @cached_property def plans(self) -> plans.AsyncPlansResourceWithRawResponse: + """Plans""" from .resources.plans import AsyncPlansResourceWithRawResponse return AsyncPlansResourceWithRawResponse(self._client.plans) @cached_property def entries(self) -> entries.AsyncEntriesResourceWithRawResponse: + """Entries""" from .resources.entries import AsyncEntriesResourceWithRawResponse return AsyncEntriesResourceWithRawResponse(self._client.entries) @cached_property def forum_posts(self) -> forum_posts.AsyncForumPostsResourceWithRawResponse: + """Forum posts""" from .resources.forum_posts import AsyncForumPostsResourceWithRawResponse return AsyncForumPostsResourceWithRawResponse(self._client.forum_posts) @cached_property def transfers(self) -> transfers.AsyncTransfersResourceWithRawResponse: + """Transfers""" from .resources.transfers import AsyncTransfersResourceWithRawResponse return AsyncTransfersResourceWithRawResponse(self._client.transfers) @cached_property def ledger_accounts(self) -> ledger_accounts.AsyncLedgerAccountsResourceWithRawResponse: + """Ledger accounts""" from .resources.ledger_accounts import AsyncLedgerAccountsResourceWithRawResponse return AsyncLedgerAccountsResourceWithRawResponse(self._client.ledger_accounts) @cached_property def memberships(self) -> memberships.AsyncMembershipsResourceWithRawResponse: + """Memberships""" from .resources.memberships import AsyncMembershipsResourceWithRawResponse return AsyncMembershipsResourceWithRawResponse(self._client.memberships) @cached_property def authorized_users(self) -> authorized_users.AsyncAuthorizedUsersResourceWithRawResponse: + """Authorized users""" from .resources.authorized_users import AsyncAuthorizedUsersResourceWithRawResponse return AsyncAuthorizedUsersResourceWithRawResponse(self._client.authorized_users) @cached_property def app_builds(self) -> app_builds.AsyncAppBuildsResourceWithRawResponse: + """App builds""" from .resources.app_builds import AsyncAppBuildsResourceWithRawResponse return AsyncAppBuildsResourceWithRawResponse(self._client.app_builds) @cached_property def shipments(self) -> shipments.AsyncShipmentsResourceWithRawResponse: + """Shipments""" from .resources.shipments import AsyncShipmentsResourceWithRawResponse return AsyncShipmentsResourceWithRawResponse(self._client.shipments) @cached_property def checkout_configurations(self) -> checkout_configurations.AsyncCheckoutConfigurationsResourceWithRawResponse: + """Checkout configurations""" from .resources.checkout_configurations import AsyncCheckoutConfigurationsResourceWithRawResponse return AsyncCheckoutConfigurationsResourceWithRawResponse(self._client.checkout_configurations) @cached_property def messages(self) -> messages.AsyncMessagesResourceWithRawResponse: + """Messages""" from .resources.messages import AsyncMessagesResourceWithRawResponse return AsyncMessagesResourceWithRawResponse(self._client.messages) @cached_property def chat_channels(self) -> chat_channels.AsyncChatChannelsResourceWithRawResponse: + """Chat channels""" from .resources.chat_channels import AsyncChatChannelsResourceWithRawResponse return AsyncChatChannelsResourceWithRawResponse(self._client.chat_channels) @cached_property def users(self) -> users.AsyncUsersResourceWithRawResponse: + """Users""" from .resources.users import AsyncUsersResourceWithRawResponse return AsyncUsersResourceWithRawResponse(self._client.users) @cached_property def payments(self) -> payments.AsyncPaymentsResourceWithRawResponse: + """Payments""" from .resources.payments import AsyncPaymentsResourceWithRawResponse return AsyncPaymentsResourceWithRawResponse(self._client.payments) @cached_property def support_channels(self) -> support_channels.AsyncSupportChannelsResourceWithRawResponse: + """Support channels""" from .resources.support_channels import AsyncSupportChannelsResourceWithRawResponse return AsyncSupportChannelsResourceWithRawResponse(self._client.support_channels) @cached_property def experiences(self) -> experiences.AsyncExperiencesResourceWithRawResponse: + """Experiences""" from .resources.experiences import AsyncExperiencesResourceWithRawResponse return AsyncExperiencesResourceWithRawResponse(self._client.experiences) @cached_property def reactions(self) -> reactions.AsyncReactionsResourceWithRawResponse: + """Reactions""" from .resources.reactions import AsyncReactionsResourceWithRawResponse return AsyncReactionsResourceWithRawResponse(self._client.reactions) @cached_property def members(self) -> members.AsyncMembersResourceWithRawResponse: + """Members""" from .resources.members import AsyncMembersResourceWithRawResponse return AsyncMembersResourceWithRawResponse(self._client.members) @cached_property def forums(self) -> forums.AsyncForumsResourceWithRawResponse: + """Forums""" from .resources.forums import AsyncForumsResourceWithRawResponse return AsyncForumsResourceWithRawResponse(self._client.forums) @cached_property def promo_codes(self) -> promo_codes.AsyncPromoCodesResourceWithRawResponse: + """Promo codes""" from .resources.promo_codes import AsyncPromoCodesResourceWithRawResponse return AsyncPromoCodesResourceWithRawResponse(self._client.promo_codes) @cached_property def courses(self) -> courses.AsyncCoursesResourceWithRawResponse: + """Courses""" from .resources.courses import AsyncCoursesResourceWithRawResponse return AsyncCoursesResourceWithRawResponse(self._client.courses) @cached_property def course_chapters(self) -> course_chapters.AsyncCourseChaptersResourceWithRawResponse: + """Course chapters""" from .resources.course_chapters import AsyncCourseChaptersResourceWithRawResponse return AsyncCourseChaptersResourceWithRawResponse(self._client.course_chapters) @cached_property def course_lessons(self) -> course_lessons.AsyncCourseLessonsResourceWithRawResponse: + """Course lessons""" from .resources.course_lessons import AsyncCourseLessonsResourceWithRawResponse return AsyncCourseLessonsResourceWithRawResponse(self._client.course_lessons) @cached_property def reviews(self) -> reviews.AsyncReviewsResourceWithRawResponse: + """Reviews""" from .resources.reviews import AsyncReviewsResourceWithRawResponse return AsyncReviewsResourceWithRawResponse(self._client.reviews) @cached_property def course_students(self) -> course_students.AsyncCourseStudentsResourceWithRawResponse: + """Course students""" from .resources.course_students import AsyncCourseStudentsResourceWithRawResponse return AsyncCourseStudentsResourceWithRawResponse(self._client.course_students) @cached_property def access_tokens(self) -> access_tokens.AsyncAccessTokensResourceWithRawResponse: + """Access tokens""" from .resources.access_tokens import AsyncAccessTokensResourceWithRawResponse return AsyncAccessTokensResourceWithRawResponse(self._client.access_tokens) @cached_property def notifications(self) -> notifications.AsyncNotificationsResourceWithRawResponse: + """Notifications""" from .resources.notifications import AsyncNotificationsResourceWithRawResponse return AsyncNotificationsResourceWithRawResponse(self._client.notifications) @cached_property def disputes(self) -> disputes.AsyncDisputesResourceWithRawResponse: + """Disputes""" from .resources.disputes import AsyncDisputesResourceWithRawResponse return AsyncDisputesResourceWithRawResponse(self._client.disputes) @cached_property def refunds(self) -> refunds.AsyncRefundsResourceWithRawResponse: + """Refunds""" from .resources.refunds import AsyncRefundsResourceWithRawResponse return AsyncRefundsResourceWithRawResponse(self._client.refunds) @cached_property def withdrawals(self) -> withdrawals.AsyncWithdrawalsResourceWithRawResponse: + """Withdrawals""" from .resources.withdrawals import AsyncWithdrawalsResourceWithRawResponse return AsyncWithdrawalsResourceWithRawResponse(self._client.withdrawals) @cached_property def account_links(self) -> account_links.AsyncAccountLinksResourceWithRawResponse: + """Account links""" from .resources.account_links import AsyncAccountLinksResourceWithRawResponse return AsyncAccountLinksResourceWithRawResponse(self._client.account_links) @cached_property def setup_intents(self) -> setup_intents.AsyncSetupIntentsResourceWithRawResponse: + """Setup intents""" from .resources.setup_intents import AsyncSetupIntentsResourceWithRawResponse return AsyncSetupIntentsResourceWithRawResponse(self._client.setup_intents) @cached_property def payment_methods(self) -> payment_methods.AsyncPaymentMethodsResourceWithRawResponse: + """Payment methods""" from .resources.payment_methods import AsyncPaymentMethodsResourceWithRawResponse return AsyncPaymentMethodsResourceWithRawResponse(self._client.payment_methods) @cached_property def fee_markups(self) -> fee_markups.AsyncFeeMarkupsResourceWithRawResponse: + """Fee markups""" from .resources.fee_markups import AsyncFeeMarkupsResourceWithRawResponse return AsyncFeeMarkupsResourceWithRawResponse(self._client.fee_markups) @cached_property def payout_methods(self) -> payout_methods.AsyncPayoutMethodsResourceWithRawResponse: + """Payout methods""" from .resources.payout_methods import AsyncPayoutMethodsResourceWithRawResponse return AsyncPayoutMethodsResourceWithRawResponse(self._client.payout_methods) @cached_property def verifications(self) -> verifications.AsyncVerificationsResourceWithRawResponse: + """Verifications""" from .resources.verifications import AsyncVerificationsResourceWithRawResponse return AsyncVerificationsResourceWithRawResponse(self._client.verifications) @cached_property def leads(self) -> leads.AsyncLeadsResourceWithRawResponse: + """Leads""" from .resources.leads import AsyncLeadsResourceWithRawResponse return AsyncLeadsResourceWithRawResponse(self._client.leads) @cached_property def topups(self) -> topups.AsyncTopupsResourceWithRawResponse: + """Topups""" from .resources.topups import AsyncTopupsResourceWithRawResponse return AsyncTopupsResourceWithRawResponse(self._client.topups) @cached_property def files(self) -> files.AsyncFilesResourceWithRawResponse: + """Files""" from .resources.files import AsyncFilesResourceWithRawResponse return AsyncFilesResourceWithRawResponse(self._client.files) @@ -1708,30 +1903,35 @@ def files(self) -> files.AsyncFilesResourceWithRawResponse: def company_token_transactions( self, ) -> company_token_transactions.AsyncCompanyTokenTransactionsResourceWithRawResponse: + """Company token transactions""" from .resources.company_token_transactions import AsyncCompanyTokenTransactionsResourceWithRawResponse return AsyncCompanyTokenTransactionsResourceWithRawResponse(self._client.company_token_transactions) @cached_property def dm_members(self) -> dm_members.AsyncDmMembersResourceWithRawResponse: + """Dm members""" from .resources.dm_members import AsyncDmMembersResourceWithRawResponse return AsyncDmMembersResourceWithRawResponse(self._client.dm_members) @cached_property def ai_chats(self) -> ai_chats.AsyncAIChatsResourceWithRawResponse: + """Ai chats""" from .resources.ai_chats import AsyncAIChatsResourceWithRawResponse return AsyncAIChatsResourceWithRawResponse(self._client.ai_chats) @cached_property def dm_channels(self) -> dm_channels.AsyncDmChannelsResourceWithRawResponse: + """Dm channels""" from .resources.dm_channels import AsyncDmChannelsResourceWithRawResponse return AsyncDmChannelsResourceWithRawResponse(self._client.dm_channels) @cached_property def dispute_alerts(self) -> dispute_alerts.AsyncDisputeAlertsResourceWithRawResponse: + """Dispute alerts""" from .resources.dispute_alerts import AsyncDisputeAlertsResourceWithRawResponse return AsyncDisputeAlertsResourceWithRawResponse(self._client.dispute_alerts) @@ -1745,12 +1945,14 @@ def __init__(self, client: Whop) -> None: @cached_property def apps(self) -> apps.AppsResourceWithStreamingResponse: + """Apps""" from .resources.apps import AppsResourceWithStreamingResponse return AppsResourceWithStreamingResponse(self._client.apps) @cached_property def invoices(self) -> invoices.InvoicesResourceWithStreamingResponse: + """Invoices""" from .resources.invoices import InvoicesResourceWithStreamingResponse return InvoicesResourceWithStreamingResponse(self._client.invoices) @@ -1759,258 +1961,301 @@ def invoices(self) -> invoices.InvoicesResourceWithStreamingResponse: def course_lesson_interactions( self, ) -> course_lesson_interactions.CourseLessonInteractionsResourceWithStreamingResponse: + """Course lesson interactions""" from .resources.course_lesson_interactions import CourseLessonInteractionsResourceWithStreamingResponse return CourseLessonInteractionsResourceWithStreamingResponse(self._client.course_lesson_interactions) @cached_property def products(self) -> products.ProductsResourceWithStreamingResponse: + """Products""" from .resources.products import ProductsResourceWithStreamingResponse return ProductsResourceWithStreamingResponse(self._client.products) @cached_property def companies(self) -> companies.CompaniesResourceWithStreamingResponse: + """Companies""" from .resources.companies import CompaniesResourceWithStreamingResponse return CompaniesResourceWithStreamingResponse(self._client.companies) @cached_property def webhooks(self) -> webhooks.WebhooksResourceWithStreamingResponse: + """Webhooks""" from .resources.webhooks import WebhooksResourceWithStreamingResponse return WebhooksResourceWithStreamingResponse(self._client.webhooks) @cached_property def plans(self) -> plans.PlansResourceWithStreamingResponse: + """Plans""" from .resources.plans import PlansResourceWithStreamingResponse return PlansResourceWithStreamingResponse(self._client.plans) @cached_property def entries(self) -> entries.EntriesResourceWithStreamingResponse: + """Entries""" from .resources.entries import EntriesResourceWithStreamingResponse return EntriesResourceWithStreamingResponse(self._client.entries) @cached_property def forum_posts(self) -> forum_posts.ForumPostsResourceWithStreamingResponse: + """Forum posts""" from .resources.forum_posts import ForumPostsResourceWithStreamingResponse return ForumPostsResourceWithStreamingResponse(self._client.forum_posts) @cached_property def transfers(self) -> transfers.TransfersResourceWithStreamingResponse: + """Transfers""" from .resources.transfers import TransfersResourceWithStreamingResponse return TransfersResourceWithStreamingResponse(self._client.transfers) @cached_property def ledger_accounts(self) -> ledger_accounts.LedgerAccountsResourceWithStreamingResponse: + """Ledger accounts""" from .resources.ledger_accounts import LedgerAccountsResourceWithStreamingResponse return LedgerAccountsResourceWithStreamingResponse(self._client.ledger_accounts) @cached_property def memberships(self) -> memberships.MembershipsResourceWithStreamingResponse: + """Memberships""" from .resources.memberships import MembershipsResourceWithStreamingResponse return MembershipsResourceWithStreamingResponse(self._client.memberships) @cached_property def authorized_users(self) -> authorized_users.AuthorizedUsersResourceWithStreamingResponse: + """Authorized users""" from .resources.authorized_users import AuthorizedUsersResourceWithStreamingResponse return AuthorizedUsersResourceWithStreamingResponse(self._client.authorized_users) @cached_property def app_builds(self) -> app_builds.AppBuildsResourceWithStreamingResponse: + """App builds""" from .resources.app_builds import AppBuildsResourceWithStreamingResponse return AppBuildsResourceWithStreamingResponse(self._client.app_builds) @cached_property def shipments(self) -> shipments.ShipmentsResourceWithStreamingResponse: + """Shipments""" from .resources.shipments import ShipmentsResourceWithStreamingResponse return ShipmentsResourceWithStreamingResponse(self._client.shipments) @cached_property def checkout_configurations(self) -> checkout_configurations.CheckoutConfigurationsResourceWithStreamingResponse: + """Checkout configurations""" from .resources.checkout_configurations import CheckoutConfigurationsResourceWithStreamingResponse return CheckoutConfigurationsResourceWithStreamingResponse(self._client.checkout_configurations) @cached_property def messages(self) -> messages.MessagesResourceWithStreamingResponse: + """Messages""" from .resources.messages import MessagesResourceWithStreamingResponse return MessagesResourceWithStreamingResponse(self._client.messages) @cached_property def chat_channels(self) -> chat_channels.ChatChannelsResourceWithStreamingResponse: + """Chat channels""" from .resources.chat_channels import ChatChannelsResourceWithStreamingResponse return ChatChannelsResourceWithStreamingResponse(self._client.chat_channels) @cached_property def users(self) -> users.UsersResourceWithStreamingResponse: + """Users""" from .resources.users import UsersResourceWithStreamingResponse return UsersResourceWithStreamingResponse(self._client.users) @cached_property def payments(self) -> payments.PaymentsResourceWithStreamingResponse: + """Payments""" from .resources.payments import PaymentsResourceWithStreamingResponse return PaymentsResourceWithStreamingResponse(self._client.payments) @cached_property def support_channels(self) -> support_channels.SupportChannelsResourceWithStreamingResponse: + """Support channels""" from .resources.support_channels import SupportChannelsResourceWithStreamingResponse return SupportChannelsResourceWithStreamingResponse(self._client.support_channels) @cached_property def experiences(self) -> experiences.ExperiencesResourceWithStreamingResponse: + """Experiences""" from .resources.experiences import ExperiencesResourceWithStreamingResponse return ExperiencesResourceWithStreamingResponse(self._client.experiences) @cached_property def reactions(self) -> reactions.ReactionsResourceWithStreamingResponse: + """Reactions""" from .resources.reactions import ReactionsResourceWithStreamingResponse return ReactionsResourceWithStreamingResponse(self._client.reactions) @cached_property def members(self) -> members.MembersResourceWithStreamingResponse: + """Members""" from .resources.members import MembersResourceWithStreamingResponse return MembersResourceWithStreamingResponse(self._client.members) @cached_property def forums(self) -> forums.ForumsResourceWithStreamingResponse: + """Forums""" from .resources.forums import ForumsResourceWithStreamingResponse return ForumsResourceWithStreamingResponse(self._client.forums) @cached_property def promo_codes(self) -> promo_codes.PromoCodesResourceWithStreamingResponse: + """Promo codes""" from .resources.promo_codes import PromoCodesResourceWithStreamingResponse return PromoCodesResourceWithStreamingResponse(self._client.promo_codes) @cached_property def courses(self) -> courses.CoursesResourceWithStreamingResponse: + """Courses""" from .resources.courses import CoursesResourceWithStreamingResponse return CoursesResourceWithStreamingResponse(self._client.courses) @cached_property def course_chapters(self) -> course_chapters.CourseChaptersResourceWithStreamingResponse: + """Course chapters""" from .resources.course_chapters import CourseChaptersResourceWithStreamingResponse return CourseChaptersResourceWithStreamingResponse(self._client.course_chapters) @cached_property def course_lessons(self) -> course_lessons.CourseLessonsResourceWithStreamingResponse: + """Course lessons""" from .resources.course_lessons import CourseLessonsResourceWithStreamingResponse return CourseLessonsResourceWithStreamingResponse(self._client.course_lessons) @cached_property def reviews(self) -> reviews.ReviewsResourceWithStreamingResponse: + """Reviews""" from .resources.reviews import ReviewsResourceWithStreamingResponse return ReviewsResourceWithStreamingResponse(self._client.reviews) @cached_property def course_students(self) -> course_students.CourseStudentsResourceWithStreamingResponse: + """Course students""" from .resources.course_students import CourseStudentsResourceWithStreamingResponse return CourseStudentsResourceWithStreamingResponse(self._client.course_students) @cached_property def access_tokens(self) -> access_tokens.AccessTokensResourceWithStreamingResponse: + """Access tokens""" from .resources.access_tokens import AccessTokensResourceWithStreamingResponse return AccessTokensResourceWithStreamingResponse(self._client.access_tokens) @cached_property def notifications(self) -> notifications.NotificationsResourceWithStreamingResponse: + """Notifications""" from .resources.notifications import NotificationsResourceWithStreamingResponse return NotificationsResourceWithStreamingResponse(self._client.notifications) @cached_property def disputes(self) -> disputes.DisputesResourceWithStreamingResponse: + """Disputes""" from .resources.disputes import DisputesResourceWithStreamingResponse return DisputesResourceWithStreamingResponse(self._client.disputes) @cached_property def refunds(self) -> refunds.RefundsResourceWithStreamingResponse: + """Refunds""" from .resources.refunds import RefundsResourceWithStreamingResponse return RefundsResourceWithStreamingResponse(self._client.refunds) @cached_property def withdrawals(self) -> withdrawals.WithdrawalsResourceWithStreamingResponse: + """Withdrawals""" from .resources.withdrawals import WithdrawalsResourceWithStreamingResponse return WithdrawalsResourceWithStreamingResponse(self._client.withdrawals) @cached_property def account_links(self) -> account_links.AccountLinksResourceWithStreamingResponse: + """Account links""" from .resources.account_links import AccountLinksResourceWithStreamingResponse return AccountLinksResourceWithStreamingResponse(self._client.account_links) @cached_property def setup_intents(self) -> setup_intents.SetupIntentsResourceWithStreamingResponse: + """Setup intents""" from .resources.setup_intents import SetupIntentsResourceWithStreamingResponse return SetupIntentsResourceWithStreamingResponse(self._client.setup_intents) @cached_property def payment_methods(self) -> payment_methods.PaymentMethodsResourceWithStreamingResponse: + """Payment methods""" from .resources.payment_methods import PaymentMethodsResourceWithStreamingResponse return PaymentMethodsResourceWithStreamingResponse(self._client.payment_methods) @cached_property def fee_markups(self) -> fee_markups.FeeMarkupsResourceWithStreamingResponse: + """Fee markups""" from .resources.fee_markups import FeeMarkupsResourceWithStreamingResponse return FeeMarkupsResourceWithStreamingResponse(self._client.fee_markups) @cached_property def payout_methods(self) -> payout_methods.PayoutMethodsResourceWithStreamingResponse: + """Payout methods""" from .resources.payout_methods import PayoutMethodsResourceWithStreamingResponse return PayoutMethodsResourceWithStreamingResponse(self._client.payout_methods) @cached_property def verifications(self) -> verifications.VerificationsResourceWithStreamingResponse: + """Verifications""" from .resources.verifications import VerificationsResourceWithStreamingResponse return VerificationsResourceWithStreamingResponse(self._client.verifications) @cached_property def leads(self) -> leads.LeadsResourceWithStreamingResponse: + """Leads""" from .resources.leads import LeadsResourceWithStreamingResponse return LeadsResourceWithStreamingResponse(self._client.leads) @cached_property def topups(self) -> topups.TopupsResourceWithStreamingResponse: + """Topups""" from .resources.topups import TopupsResourceWithStreamingResponse return TopupsResourceWithStreamingResponse(self._client.topups) @cached_property def files(self) -> files.FilesResourceWithStreamingResponse: + """Files""" from .resources.files import FilesResourceWithStreamingResponse return FilesResourceWithStreamingResponse(self._client.files) @@ -2019,30 +2264,35 @@ def files(self) -> files.FilesResourceWithStreamingResponse: def company_token_transactions( self, ) -> company_token_transactions.CompanyTokenTransactionsResourceWithStreamingResponse: + """Company token transactions""" from .resources.company_token_transactions import CompanyTokenTransactionsResourceWithStreamingResponse return CompanyTokenTransactionsResourceWithStreamingResponse(self._client.company_token_transactions) @cached_property def dm_members(self) -> dm_members.DmMembersResourceWithStreamingResponse: + """Dm members""" from .resources.dm_members import DmMembersResourceWithStreamingResponse return DmMembersResourceWithStreamingResponse(self._client.dm_members) @cached_property def ai_chats(self) -> ai_chats.AIChatsResourceWithStreamingResponse: + """Ai chats""" from .resources.ai_chats import AIChatsResourceWithStreamingResponse return AIChatsResourceWithStreamingResponse(self._client.ai_chats) @cached_property def dm_channels(self) -> dm_channels.DmChannelsResourceWithStreamingResponse: + """Dm channels""" from .resources.dm_channels import DmChannelsResourceWithStreamingResponse return DmChannelsResourceWithStreamingResponse(self._client.dm_channels) @cached_property def dispute_alerts(self) -> dispute_alerts.DisputeAlertsResourceWithStreamingResponse: + """Dispute alerts""" from .resources.dispute_alerts import DisputeAlertsResourceWithStreamingResponse return DisputeAlertsResourceWithStreamingResponse(self._client.dispute_alerts) @@ -2056,12 +2306,14 @@ def __init__(self, client: AsyncWhop) -> None: @cached_property def apps(self) -> apps.AsyncAppsResourceWithStreamingResponse: + """Apps""" from .resources.apps import AsyncAppsResourceWithStreamingResponse return AsyncAppsResourceWithStreamingResponse(self._client.apps) @cached_property def invoices(self) -> invoices.AsyncInvoicesResourceWithStreamingResponse: + """Invoices""" from .resources.invoices import AsyncInvoicesResourceWithStreamingResponse return AsyncInvoicesResourceWithStreamingResponse(self._client.invoices) @@ -2070,78 +2322,91 @@ def invoices(self) -> invoices.AsyncInvoicesResourceWithStreamingResponse: def course_lesson_interactions( self, ) -> course_lesson_interactions.AsyncCourseLessonInteractionsResourceWithStreamingResponse: + """Course lesson interactions""" from .resources.course_lesson_interactions import AsyncCourseLessonInteractionsResourceWithStreamingResponse return AsyncCourseLessonInteractionsResourceWithStreamingResponse(self._client.course_lesson_interactions) @cached_property def products(self) -> products.AsyncProductsResourceWithStreamingResponse: + """Products""" from .resources.products import AsyncProductsResourceWithStreamingResponse return AsyncProductsResourceWithStreamingResponse(self._client.products) @cached_property def companies(self) -> companies.AsyncCompaniesResourceWithStreamingResponse: + """Companies""" from .resources.companies import AsyncCompaniesResourceWithStreamingResponse return AsyncCompaniesResourceWithStreamingResponse(self._client.companies) @cached_property def webhooks(self) -> webhooks.AsyncWebhooksResourceWithStreamingResponse: + """Webhooks""" from .resources.webhooks import AsyncWebhooksResourceWithStreamingResponse return AsyncWebhooksResourceWithStreamingResponse(self._client.webhooks) @cached_property def plans(self) -> plans.AsyncPlansResourceWithStreamingResponse: + """Plans""" from .resources.plans import AsyncPlansResourceWithStreamingResponse return AsyncPlansResourceWithStreamingResponse(self._client.plans) @cached_property def entries(self) -> entries.AsyncEntriesResourceWithStreamingResponse: + """Entries""" from .resources.entries import AsyncEntriesResourceWithStreamingResponse return AsyncEntriesResourceWithStreamingResponse(self._client.entries) @cached_property def forum_posts(self) -> forum_posts.AsyncForumPostsResourceWithStreamingResponse: + """Forum posts""" from .resources.forum_posts import AsyncForumPostsResourceWithStreamingResponse return AsyncForumPostsResourceWithStreamingResponse(self._client.forum_posts) @cached_property def transfers(self) -> transfers.AsyncTransfersResourceWithStreamingResponse: + """Transfers""" from .resources.transfers import AsyncTransfersResourceWithStreamingResponse return AsyncTransfersResourceWithStreamingResponse(self._client.transfers) @cached_property def ledger_accounts(self) -> ledger_accounts.AsyncLedgerAccountsResourceWithStreamingResponse: + """Ledger accounts""" from .resources.ledger_accounts import AsyncLedgerAccountsResourceWithStreamingResponse return AsyncLedgerAccountsResourceWithStreamingResponse(self._client.ledger_accounts) @cached_property def memberships(self) -> memberships.AsyncMembershipsResourceWithStreamingResponse: + """Memberships""" from .resources.memberships import AsyncMembershipsResourceWithStreamingResponse return AsyncMembershipsResourceWithStreamingResponse(self._client.memberships) @cached_property def authorized_users(self) -> authorized_users.AsyncAuthorizedUsersResourceWithStreamingResponse: + """Authorized users""" from .resources.authorized_users import AsyncAuthorizedUsersResourceWithStreamingResponse return AsyncAuthorizedUsersResourceWithStreamingResponse(self._client.authorized_users) @cached_property def app_builds(self) -> app_builds.AsyncAppBuildsResourceWithStreamingResponse: + """App builds""" from .resources.app_builds import AsyncAppBuildsResourceWithStreamingResponse return AsyncAppBuildsResourceWithStreamingResponse(self._client.app_builds) @cached_property def shipments(self) -> shipments.AsyncShipmentsResourceWithStreamingResponse: + """Shipments""" from .resources.shipments import AsyncShipmentsResourceWithStreamingResponse return AsyncShipmentsResourceWithStreamingResponse(self._client.shipments) @@ -2150,180 +2415,210 @@ def shipments(self) -> shipments.AsyncShipmentsResourceWithStreamingResponse: def checkout_configurations( self, ) -> checkout_configurations.AsyncCheckoutConfigurationsResourceWithStreamingResponse: + """Checkout configurations""" from .resources.checkout_configurations import AsyncCheckoutConfigurationsResourceWithStreamingResponse return AsyncCheckoutConfigurationsResourceWithStreamingResponse(self._client.checkout_configurations) @cached_property def messages(self) -> messages.AsyncMessagesResourceWithStreamingResponse: + """Messages""" from .resources.messages import AsyncMessagesResourceWithStreamingResponse return AsyncMessagesResourceWithStreamingResponse(self._client.messages) @cached_property def chat_channels(self) -> chat_channels.AsyncChatChannelsResourceWithStreamingResponse: + """Chat channels""" from .resources.chat_channels import AsyncChatChannelsResourceWithStreamingResponse return AsyncChatChannelsResourceWithStreamingResponse(self._client.chat_channels) @cached_property def users(self) -> users.AsyncUsersResourceWithStreamingResponse: + """Users""" from .resources.users import AsyncUsersResourceWithStreamingResponse return AsyncUsersResourceWithStreamingResponse(self._client.users) @cached_property def payments(self) -> payments.AsyncPaymentsResourceWithStreamingResponse: + """Payments""" from .resources.payments import AsyncPaymentsResourceWithStreamingResponse return AsyncPaymentsResourceWithStreamingResponse(self._client.payments) @cached_property def support_channels(self) -> support_channels.AsyncSupportChannelsResourceWithStreamingResponse: + """Support channels""" from .resources.support_channels import AsyncSupportChannelsResourceWithStreamingResponse return AsyncSupportChannelsResourceWithStreamingResponse(self._client.support_channels) @cached_property def experiences(self) -> experiences.AsyncExperiencesResourceWithStreamingResponse: + """Experiences""" from .resources.experiences import AsyncExperiencesResourceWithStreamingResponse return AsyncExperiencesResourceWithStreamingResponse(self._client.experiences) @cached_property def reactions(self) -> reactions.AsyncReactionsResourceWithStreamingResponse: + """Reactions""" from .resources.reactions import AsyncReactionsResourceWithStreamingResponse return AsyncReactionsResourceWithStreamingResponse(self._client.reactions) @cached_property def members(self) -> members.AsyncMembersResourceWithStreamingResponse: + """Members""" from .resources.members import AsyncMembersResourceWithStreamingResponse return AsyncMembersResourceWithStreamingResponse(self._client.members) @cached_property def forums(self) -> forums.AsyncForumsResourceWithStreamingResponse: + """Forums""" from .resources.forums import AsyncForumsResourceWithStreamingResponse return AsyncForumsResourceWithStreamingResponse(self._client.forums) @cached_property def promo_codes(self) -> promo_codes.AsyncPromoCodesResourceWithStreamingResponse: + """Promo codes""" from .resources.promo_codes import AsyncPromoCodesResourceWithStreamingResponse return AsyncPromoCodesResourceWithStreamingResponse(self._client.promo_codes) @cached_property def courses(self) -> courses.AsyncCoursesResourceWithStreamingResponse: + """Courses""" from .resources.courses import AsyncCoursesResourceWithStreamingResponse return AsyncCoursesResourceWithStreamingResponse(self._client.courses) @cached_property def course_chapters(self) -> course_chapters.AsyncCourseChaptersResourceWithStreamingResponse: + """Course chapters""" from .resources.course_chapters import AsyncCourseChaptersResourceWithStreamingResponse return AsyncCourseChaptersResourceWithStreamingResponse(self._client.course_chapters) @cached_property def course_lessons(self) -> course_lessons.AsyncCourseLessonsResourceWithStreamingResponse: + """Course lessons""" from .resources.course_lessons import AsyncCourseLessonsResourceWithStreamingResponse return AsyncCourseLessonsResourceWithStreamingResponse(self._client.course_lessons) @cached_property def reviews(self) -> reviews.AsyncReviewsResourceWithStreamingResponse: + """Reviews""" from .resources.reviews import AsyncReviewsResourceWithStreamingResponse return AsyncReviewsResourceWithStreamingResponse(self._client.reviews) @cached_property def course_students(self) -> course_students.AsyncCourseStudentsResourceWithStreamingResponse: + """Course students""" from .resources.course_students import AsyncCourseStudentsResourceWithStreamingResponse return AsyncCourseStudentsResourceWithStreamingResponse(self._client.course_students) @cached_property def access_tokens(self) -> access_tokens.AsyncAccessTokensResourceWithStreamingResponse: + """Access tokens""" from .resources.access_tokens import AsyncAccessTokensResourceWithStreamingResponse return AsyncAccessTokensResourceWithStreamingResponse(self._client.access_tokens) @cached_property def notifications(self) -> notifications.AsyncNotificationsResourceWithStreamingResponse: + """Notifications""" from .resources.notifications import AsyncNotificationsResourceWithStreamingResponse return AsyncNotificationsResourceWithStreamingResponse(self._client.notifications) @cached_property def disputes(self) -> disputes.AsyncDisputesResourceWithStreamingResponse: + """Disputes""" from .resources.disputes import AsyncDisputesResourceWithStreamingResponse return AsyncDisputesResourceWithStreamingResponse(self._client.disputes) @cached_property def refunds(self) -> refunds.AsyncRefundsResourceWithStreamingResponse: + """Refunds""" from .resources.refunds import AsyncRefundsResourceWithStreamingResponse return AsyncRefundsResourceWithStreamingResponse(self._client.refunds) @cached_property def withdrawals(self) -> withdrawals.AsyncWithdrawalsResourceWithStreamingResponse: + """Withdrawals""" from .resources.withdrawals import AsyncWithdrawalsResourceWithStreamingResponse return AsyncWithdrawalsResourceWithStreamingResponse(self._client.withdrawals) @cached_property def account_links(self) -> account_links.AsyncAccountLinksResourceWithStreamingResponse: + """Account links""" from .resources.account_links import AsyncAccountLinksResourceWithStreamingResponse return AsyncAccountLinksResourceWithStreamingResponse(self._client.account_links) @cached_property def setup_intents(self) -> setup_intents.AsyncSetupIntentsResourceWithStreamingResponse: + """Setup intents""" from .resources.setup_intents import AsyncSetupIntentsResourceWithStreamingResponse return AsyncSetupIntentsResourceWithStreamingResponse(self._client.setup_intents) @cached_property def payment_methods(self) -> payment_methods.AsyncPaymentMethodsResourceWithStreamingResponse: + """Payment methods""" from .resources.payment_methods import AsyncPaymentMethodsResourceWithStreamingResponse return AsyncPaymentMethodsResourceWithStreamingResponse(self._client.payment_methods) @cached_property def fee_markups(self) -> fee_markups.AsyncFeeMarkupsResourceWithStreamingResponse: + """Fee markups""" from .resources.fee_markups import AsyncFeeMarkupsResourceWithStreamingResponse return AsyncFeeMarkupsResourceWithStreamingResponse(self._client.fee_markups) @cached_property def payout_methods(self) -> payout_methods.AsyncPayoutMethodsResourceWithStreamingResponse: + """Payout methods""" from .resources.payout_methods import AsyncPayoutMethodsResourceWithStreamingResponse return AsyncPayoutMethodsResourceWithStreamingResponse(self._client.payout_methods) @cached_property def verifications(self) -> verifications.AsyncVerificationsResourceWithStreamingResponse: + """Verifications""" from .resources.verifications import AsyncVerificationsResourceWithStreamingResponse return AsyncVerificationsResourceWithStreamingResponse(self._client.verifications) @cached_property def leads(self) -> leads.AsyncLeadsResourceWithStreamingResponse: + """Leads""" from .resources.leads import AsyncLeadsResourceWithStreamingResponse return AsyncLeadsResourceWithStreamingResponse(self._client.leads) @cached_property def topups(self) -> topups.AsyncTopupsResourceWithStreamingResponse: + """Topups""" from .resources.topups import AsyncTopupsResourceWithStreamingResponse return AsyncTopupsResourceWithStreamingResponse(self._client.topups) @cached_property def files(self) -> files.AsyncFilesResourceWithStreamingResponse: + """Files""" from .resources.files import AsyncFilesResourceWithStreamingResponse return AsyncFilesResourceWithStreamingResponse(self._client.files) @@ -2332,30 +2627,35 @@ def files(self) -> files.AsyncFilesResourceWithStreamingResponse: def company_token_transactions( self, ) -> company_token_transactions.AsyncCompanyTokenTransactionsResourceWithStreamingResponse: + """Company token transactions""" from .resources.company_token_transactions import AsyncCompanyTokenTransactionsResourceWithStreamingResponse return AsyncCompanyTokenTransactionsResourceWithStreamingResponse(self._client.company_token_transactions) @cached_property def dm_members(self) -> dm_members.AsyncDmMembersResourceWithStreamingResponse: + """Dm members""" from .resources.dm_members import AsyncDmMembersResourceWithStreamingResponse return AsyncDmMembersResourceWithStreamingResponse(self._client.dm_members) @cached_property def ai_chats(self) -> ai_chats.AsyncAIChatsResourceWithStreamingResponse: + """Ai chats""" from .resources.ai_chats import AsyncAIChatsResourceWithStreamingResponse return AsyncAIChatsResourceWithStreamingResponse(self._client.ai_chats) @cached_property def dm_channels(self) -> dm_channels.AsyncDmChannelsResourceWithStreamingResponse: + """Dm channels""" from .resources.dm_channels import AsyncDmChannelsResourceWithStreamingResponse return AsyncDmChannelsResourceWithStreamingResponse(self._client.dm_channels) @cached_property def dispute_alerts(self) -> dispute_alerts.AsyncDisputeAlertsResourceWithStreamingResponse: + """Dispute alerts""" from .resources.dispute_alerts import AsyncDisputeAlertsResourceWithStreamingResponse return AsyncDisputeAlertsResourceWithStreamingResponse(self._client.dispute_alerts) diff --git a/src/whop_sdk/_version.py b/src/whop_sdk/_version.py index c674ff57..162053b4 100644 --- a/src/whop_sdk/_version.py +++ b/src/whop_sdk/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "whop_sdk" -__version__ = "0.0.30" # x-release-please-version +__version__ = "0.1.0" # x-release-please-version diff --git a/src/whop_sdk/resources/access_tokens.py b/src/whop_sdk/resources/access_tokens.py index ec9b7832..1ebde168 100644 --- a/src/whop_sdk/resources/access_tokens.py +++ b/src/whop_sdk/resources/access_tokens.py @@ -25,6 +25,8 @@ class AccessTokensResource(SyncAPIResource): + """Access tokens""" + @cached_property def with_raw_response(self) -> AccessTokensResourceWithRawResponse: """ @@ -106,6 +108,8 @@ def create( class AsyncAccessTokensResource(AsyncAPIResource): + """Access tokens""" + @cached_property def with_raw_response(self) -> AsyncAccessTokensResourceWithRawResponse: """ diff --git a/src/whop_sdk/resources/account_links.py b/src/whop_sdk/resources/account_links.py index e362e3fb..ccfe5cd7 100644 --- a/src/whop_sdk/resources/account_links.py +++ b/src/whop_sdk/resources/account_links.py @@ -24,6 +24,8 @@ class AccountLinksResource(SyncAPIResource): + """Account links""" + @cached_property def with_raw_response(self) -> AccountLinksResourceWithRawResponse: """ @@ -101,6 +103,8 @@ def create( class AsyncAccountLinksResource(AsyncAPIResource): + """Account links""" + @cached_property def with_raw_response(self) -> AsyncAccountLinksResourceWithRawResponse: """ diff --git a/src/whop_sdk/resources/ai_chats.py b/src/whop_sdk/resources/ai_chats.py index cd24246c..cd1fe56a 100644 --- a/src/whop_sdk/resources/ai_chats.py +++ b/src/whop_sdk/resources/ai_chats.py @@ -28,6 +28,8 @@ class AIChatsResource(SyncAPIResource): + """Ai chats""" + @cached_property def with_raw_response(self) -> AIChatsResourceWithRawResponse: """ @@ -54,6 +56,7 @@ def create( current_company_id: Optional[str] | Omit = omit, message_attachments: Optional[Iterable[ai_chat_create_params.MessageAttachment]] | Omit = omit, message_source: Optional[Literal["manual", "suggestion", "link"]] | Omit = omit, + suggestion_type: Optional[str] | Omit = omit, title: Optional[str] | Omit = omit, # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. # The extra values given here take precedence over values defined on the client or passed to this method. @@ -80,6 +83,9 @@ def create( message_source: The source of an AI chat message + suggestion_type: The type of suggestion prompt that was clicked, when message_source is + 'suggestion'. + title: An optional display title for the AI chat thread (e.g., "Help with billing"). extra_headers: Send extra headers @@ -98,6 +104,7 @@ def create( "current_company_id": current_company_id, "message_attachments": message_attachments, "message_source": message_source, + "suggestion_type": suggestion_type, "title": title, }, ai_chat_create_params.AIChatCreateParams, @@ -286,6 +293,8 @@ def delete( class AsyncAIChatsResource(AsyncAPIResource): + """Ai chats""" + @cached_property def with_raw_response(self) -> AsyncAIChatsResourceWithRawResponse: """ @@ -312,6 +321,7 @@ async def create( current_company_id: Optional[str] | Omit = omit, message_attachments: Optional[Iterable[ai_chat_create_params.MessageAttachment]] | Omit = omit, message_source: Optional[Literal["manual", "suggestion", "link"]] | Omit = omit, + suggestion_type: Optional[str] | Omit = omit, title: Optional[str] | Omit = omit, # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. # The extra values given here take precedence over values defined on the client or passed to this method. @@ -338,6 +348,9 @@ async def create( message_source: The source of an AI chat message + suggestion_type: The type of suggestion prompt that was clicked, when message_source is + 'suggestion'. + title: An optional display title for the AI chat thread (e.g., "Help with billing"). extra_headers: Send extra headers @@ -356,6 +369,7 @@ async def create( "current_company_id": current_company_id, "message_attachments": message_attachments, "message_source": message_source, + "suggestion_type": suggestion_type, "title": title, }, ai_chat_create_params.AIChatCreateParams, diff --git a/src/whop_sdk/resources/app_builds.py b/src/whop_sdk/resources/app_builds.py index e4e0f855..967b89fd 100644 --- a/src/whop_sdk/resources/app_builds.py +++ b/src/whop_sdk/resources/app_builds.py @@ -30,6 +30,8 @@ class AppBuildsResource(SyncAPIResource): + """App builds""" + @cached_property def with_raw_response(self) -> AppBuildsResourceWithRawResponse: """ @@ -276,6 +278,8 @@ def promote( class AsyncAppBuildsResource(AsyncAPIResource): + """App builds""" + @cached_property def with_raw_response(self) -> AsyncAppBuildsResourceWithRawResponse: """ diff --git a/src/whop_sdk/resources/apps.py b/src/whop_sdk/resources/apps.py index 46fd9b78..dd29aa84 100644 --- a/src/whop_sdk/resources/apps.py +++ b/src/whop_sdk/resources/apps.py @@ -31,6 +31,8 @@ class AppsResource(SyncAPIResource): + """Apps""" + @cached_property def with_raw_response(self) -> AppsResourceWithRawResponse: """ @@ -354,6 +356,8 @@ def list( class AsyncAppsResource(AsyncAPIResource): + """Apps""" + @cached_property def with_raw_response(self) -> AsyncAppsResourceWithRawResponse: """ diff --git a/src/whop_sdk/resources/authorized_users.py b/src/whop_sdk/resources/authorized_users.py index 91158b83..b1f3fd19 100644 --- a/src/whop_sdk/resources/authorized_users.py +++ b/src/whop_sdk/resources/authorized_users.py @@ -7,9 +7,9 @@ import httpx -from ..types import authorized_user_list_params +from ..types import authorized_user_list_params, authorized_user_create_params, authorized_user_delete_params from .._types import Body, Omit, Query, Headers, NotGiven, omit, not_given -from .._utils import maybe_transform +from .._utils import maybe_transform, async_maybe_transform from .._compat import cached_property from .._resource import SyncAPIResource, AsyncAPIResource from .._response import ( @@ -22,12 +22,16 @@ from .._base_client import AsyncPaginator, make_request_options from ..types.shared.authorized_user_roles import AuthorizedUserRoles from ..types.authorized_user_list_response import AuthorizedUserListResponse +from ..types.authorized_user_create_response import AuthorizedUserCreateResponse +from ..types.authorized_user_delete_response import AuthorizedUserDeleteResponse from ..types.authorized_user_retrieve_response import AuthorizedUserRetrieveResponse __all__ = ["AuthorizedUsersResource", "AsyncAuthorizedUsersResource"] class AuthorizedUsersResource(SyncAPIResource): + """Authorized users""" + @cached_property def with_raw_response(self) -> AuthorizedUsersResourceWithRawResponse: """ @@ -47,6 +51,64 @@ def with_streaming_response(self) -> AuthorizedUsersResourceWithStreamingRespons """ return AuthorizedUsersResourceWithStreamingResponse(self) + def create( + self, + *, + company_id: str, + role: AuthorizedUserRoles, + user_id: str, + send_emails: Optional[bool] | 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, + ) -> AuthorizedUserCreateResponse: + """ + Add a new authorized user to a company. + + Required permissions: + + - `authorized_user:create` + - `member:email:read` + + Args: + company_id: The ID of the company to add the authorized user to. + + role: + The role to assign to the authorized user within the company. Supported roles: + 'moderator', 'sales_manager'. + + user_id: The ID of the user to add as an authorized user. + + send_emails: Whether to send notification emails to the user on creation. + + 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._post( + "/authorized_users", + body=maybe_transform( + { + "company_id": company_id, + "role": role, + "user_id": user_id, + "send_emails": send_emails, + }, + authorized_user_create_params.AuthorizedUserCreateParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=AuthorizedUserCreateResponse, + ) + def retrieve( self, id: str, @@ -167,8 +229,57 @@ def list( model=AuthorizedUserListResponse, ) + def delete( + self, + id: str, + *, + company_id: Optional[str] | Omit = omit, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> AuthorizedUserDeleteResponse: + """ + Remove an authorized user from a company. + + Required permissions: + + - `authorized_user:delete` + + Args: + company_id: The ID of the company the authorized user belongs to. Optional if the authorized + user ID is provided. + + 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 id: + raise ValueError(f"Expected a non-empty value for `id` but received {id!r}") + return self._delete( + f"/authorized_users/{id}", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=maybe_transform( + {"company_id": company_id}, authorized_user_delete_params.AuthorizedUserDeleteParams + ), + ), + cast_to=AuthorizedUserDeleteResponse, + ) + class AsyncAuthorizedUsersResource(AsyncAPIResource): + """Authorized users""" + @cached_property def with_raw_response(self) -> AsyncAuthorizedUsersResourceWithRawResponse: """ @@ -188,6 +299,64 @@ def with_streaming_response(self) -> AsyncAuthorizedUsersResourceWithStreamingRe """ return AsyncAuthorizedUsersResourceWithStreamingResponse(self) + async def create( + self, + *, + company_id: str, + role: AuthorizedUserRoles, + user_id: str, + send_emails: Optional[bool] | 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, + ) -> AuthorizedUserCreateResponse: + """ + Add a new authorized user to a company. + + Required permissions: + + - `authorized_user:create` + - `member:email:read` + + Args: + company_id: The ID of the company to add the authorized user to. + + role: + The role to assign to the authorized user within the company. Supported roles: + 'moderator', 'sales_manager'. + + user_id: The ID of the user to add as an authorized user. + + send_emails: Whether to send notification emails to the user on creation. + + 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 await self._post( + "/authorized_users", + body=await async_maybe_transform( + { + "company_id": company_id, + "role": role, + "user_id": user_id, + "send_emails": send_emails, + }, + authorized_user_create_params.AuthorizedUserCreateParams, + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=AuthorizedUserCreateResponse, + ) + async def retrieve( self, id: str, @@ -308,50 +477,121 @@ def list( model=AuthorizedUserListResponse, ) + async def delete( + self, + id: str, + *, + company_id: Optional[str] | Omit = omit, + # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. + # The extra values given here take precedence over values defined on the client or passed to this method. + extra_headers: Headers | None = None, + extra_query: Query | None = None, + extra_body: Body | None = None, + timeout: float | httpx.Timeout | None | NotGiven = not_given, + ) -> AuthorizedUserDeleteResponse: + """ + Remove an authorized user from a company. + + Required permissions: + + - `authorized_user:delete` + + Args: + company_id: The ID of the company the authorized user belongs to. Optional if the authorized + user ID is provided. + + 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 id: + raise ValueError(f"Expected a non-empty value for `id` but received {id!r}") + return await self._delete( + f"/authorized_users/{id}", + options=make_request_options( + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + query=await async_maybe_transform( + {"company_id": company_id}, authorized_user_delete_params.AuthorizedUserDeleteParams + ), + ), + cast_to=AuthorizedUserDeleteResponse, + ) + class AuthorizedUsersResourceWithRawResponse: def __init__(self, authorized_users: AuthorizedUsersResource) -> None: self._authorized_users = authorized_users + self.create = to_raw_response_wrapper( + authorized_users.create, + ) self.retrieve = to_raw_response_wrapper( authorized_users.retrieve, ) self.list = to_raw_response_wrapper( authorized_users.list, ) + self.delete = to_raw_response_wrapper( + authorized_users.delete, + ) class AsyncAuthorizedUsersResourceWithRawResponse: def __init__(self, authorized_users: AsyncAuthorizedUsersResource) -> None: self._authorized_users = authorized_users + self.create = async_to_raw_response_wrapper( + authorized_users.create, + ) self.retrieve = async_to_raw_response_wrapper( authorized_users.retrieve, ) self.list = async_to_raw_response_wrapper( authorized_users.list, ) + self.delete = async_to_raw_response_wrapper( + authorized_users.delete, + ) class AuthorizedUsersResourceWithStreamingResponse: def __init__(self, authorized_users: AuthorizedUsersResource) -> None: self._authorized_users = authorized_users + self.create = to_streamed_response_wrapper( + authorized_users.create, + ) self.retrieve = to_streamed_response_wrapper( authorized_users.retrieve, ) self.list = to_streamed_response_wrapper( authorized_users.list, ) + self.delete = to_streamed_response_wrapper( + authorized_users.delete, + ) class AsyncAuthorizedUsersResourceWithStreamingResponse: def __init__(self, authorized_users: AsyncAuthorizedUsersResource) -> None: self._authorized_users = authorized_users + self.create = async_to_streamed_response_wrapper( + authorized_users.create, + ) self.retrieve = async_to_streamed_response_wrapper( authorized_users.retrieve, ) self.list = async_to_streamed_response_wrapper( authorized_users.list, ) + self.delete = async_to_streamed_response_wrapper( + authorized_users.delete, + ) diff --git a/src/whop_sdk/resources/chat_channels.py b/src/whop_sdk/resources/chat_channels.py index 0ed7bd7f..04382738 100644 --- a/src/whop_sdk/resources/chat_channels.py +++ b/src/whop_sdk/resources/chat_channels.py @@ -28,6 +28,8 @@ class ChatChannelsResource(SyncAPIResource): + """Chat channels""" + @cached_property def with_raw_response(self) -> ChatChannelsResourceWithRawResponse: """ @@ -224,6 +226,8 @@ def list( class AsyncChatChannelsResource(AsyncAPIResource): + """Chat channels""" + @cached_property def with_raw_response(self) -> AsyncChatChannelsResourceWithRawResponse: """ diff --git a/src/whop_sdk/resources/checkout_configurations.py b/src/whop_sdk/resources/checkout_configurations.py index 01606287..8df82b2c 100644 --- a/src/whop_sdk/resources/checkout_configurations.py +++ b/src/whop_sdk/resources/checkout_configurations.py @@ -30,6 +30,8 @@ class CheckoutConfigurationsResource(SyncAPIResource): + """Checkout configurations""" + @cached_property def with_raw_response(self) -> CheckoutConfigurationsResourceWithRawResponse: """ @@ -396,6 +398,8 @@ def list( class AsyncCheckoutConfigurationsResource(AsyncAPIResource): + """Checkout configurations""" + @cached_property def with_raw_response(self) -> AsyncCheckoutConfigurationsResourceWithRawResponse: """ diff --git a/src/whop_sdk/resources/companies.py b/src/whop_sdk/resources/companies.py index 37cb0775..ae00db09 100644 --- a/src/whop_sdk/resources/companies.py +++ b/src/whop_sdk/resources/companies.py @@ -2,7 +2,7 @@ from __future__ import annotations -from typing import Dict, Union, Optional +from typing import Dict, Union, Iterable, Optional from datetime import datetime import httpx @@ -28,6 +28,8 @@ class CompaniesResource(SyncAPIResource): + """Companies""" + @cached_property def with_raw_response(self) -> CompaniesResourceWithRawResponse: """ @@ -168,6 +170,7 @@ def update( logo: Optional[company_update_params.Logo] | Omit = omit, route: Optional[str] | Omit = omit, send_customer_emails: Optional[bool] | Omit = omit, + social_links: Optional[Iterable[company_update_params.SocialLink]] | Omit = omit, target_audience: Optional[str] | Omit = omit, title: Optional[str] | Omit = omit, # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. @@ -200,6 +203,9 @@ def update( send_customer_emails: Whether Whop sends transactional emails (receipts, renewals, cancelations) to customers on behalf of this company. + social_links: The social media links to display on the company's store page. Pass the full + list of desired social links — any existing links not included will be removed. + target_audience: The target audience for this company (e.g., 'beginner day traders aged 18-25 looking to learn options'). @@ -224,6 +230,7 @@ def update( "logo": logo, "route": route, "send_customer_emails": send_customer_emails, + "social_links": social_links, "target_audience": target_audience, "title": title, }, @@ -317,6 +324,8 @@ def list( class AsyncCompaniesResource(AsyncAPIResource): + """Companies""" + @cached_property def with_raw_response(self) -> AsyncCompaniesResourceWithRawResponse: """ @@ -457,6 +466,7 @@ async def update( logo: Optional[company_update_params.Logo] | Omit = omit, route: Optional[str] | Omit = omit, send_customer_emails: Optional[bool] | Omit = omit, + social_links: Optional[Iterable[company_update_params.SocialLink]] | Omit = omit, target_audience: Optional[str] | Omit = omit, title: Optional[str] | Omit = omit, # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. @@ -489,6 +499,9 @@ async def update( send_customer_emails: Whether Whop sends transactional emails (receipts, renewals, cancelations) to customers on behalf of this company. + social_links: The social media links to display on the company's store page. Pass the full + list of desired social links — any existing links not included will be removed. + target_audience: The target audience for this company (e.g., 'beginner day traders aged 18-25 looking to learn options'). @@ -513,6 +526,7 @@ async def update( "logo": logo, "route": route, "send_customer_emails": send_customer_emails, + "social_links": social_links, "target_audience": target_audience, "title": title, }, diff --git a/src/whop_sdk/resources/company_token_transactions.py b/src/whop_sdk/resources/company_token_transactions.py index aa7bf6ce..ff382499 100644 --- a/src/whop_sdk/resources/company_token_transactions.py +++ b/src/whop_sdk/resources/company_token_transactions.py @@ -32,6 +32,8 @@ class CompanyTokenTransactionsResource(SyncAPIResource): + """Company token transactions""" + @cached_property def with_raw_response(self) -> CompanyTokenTransactionsResourceWithRawResponse: """ @@ -365,6 +367,8 @@ def list( class AsyncCompanyTokenTransactionsResource(AsyncAPIResource): + """Company token transactions""" + @cached_property def with_raw_response(self) -> AsyncCompanyTokenTransactionsResourceWithRawResponse: """ diff --git a/src/whop_sdk/resources/course_chapters.py b/src/whop_sdk/resources/course_chapters.py index 9d8345bf..13d1ba92 100644 --- a/src/whop_sdk/resources/course_chapters.py +++ b/src/whop_sdk/resources/course_chapters.py @@ -27,6 +27,8 @@ class CourseChaptersResource(SyncAPIResource): + """Course chapters""" + @cached_property def with_raw_response(self) -> CourseChaptersResourceWithRawResponse: """ @@ -274,6 +276,8 @@ def delete( class AsyncCourseChaptersResource(AsyncAPIResource): + """Course chapters""" + @cached_property def with_raw_response(self) -> AsyncCourseChaptersResourceWithRawResponse: """ diff --git a/src/whop_sdk/resources/course_lesson_interactions.py b/src/whop_sdk/resources/course_lesson_interactions.py index 19d49434..c162930e 100644 --- a/src/whop_sdk/resources/course_lesson_interactions.py +++ b/src/whop_sdk/resources/course_lesson_interactions.py @@ -26,6 +26,8 @@ class CourseLessonInteractionsResource(SyncAPIResource): + """Course lesson interactions""" + @cached_property def with_raw_response(self) -> CourseLessonInteractionsResourceWithRawResponse: """ @@ -162,6 +164,8 @@ def list( class AsyncCourseLessonInteractionsResource(AsyncAPIResource): + """Course lesson interactions""" + @cached_property def with_raw_response(self) -> AsyncCourseLessonInteractionsResourceWithRawResponse: """ diff --git a/src/whop_sdk/resources/course_lessons.py b/src/whop_sdk/resources/course_lessons.py index ef47ad3e..710a739d 100644 --- a/src/whop_sdk/resources/course_lessons.py +++ b/src/whop_sdk/resources/course_lessons.py @@ -41,6 +41,8 @@ class CourseLessonsResource(SyncAPIResource): + """Course lessons""" + @cached_property def with_raw_response(self) -> CourseLessonsResourceWithRawResponse: """ @@ -493,6 +495,8 @@ def submit_assessment( class AsyncCourseLessonsResource(AsyncAPIResource): + """Course lessons""" + @cached_property def with_raw_response(self) -> AsyncCourseLessonsResourceWithRawResponse: """ diff --git a/src/whop_sdk/resources/course_students.py b/src/whop_sdk/resources/course_students.py index 83c1656e..f85f1f82 100644 --- a/src/whop_sdk/resources/course_students.py +++ b/src/whop_sdk/resources/course_students.py @@ -26,6 +26,8 @@ class CourseStudentsResource(SyncAPIResource): + """Course students""" + @cached_property def with_raw_response(self) -> CourseStudentsResourceWithRawResponse: """ @@ -154,6 +156,8 @@ def list( class AsyncCourseStudentsResource(AsyncAPIResource): + """Course students""" + @cached_property def with_raw_response(self) -> AsyncCourseStudentsResourceWithRawResponse: """ diff --git a/src/whop_sdk/resources/courses.py b/src/whop_sdk/resources/courses.py index a5c5b25e..9ea8d328 100644 --- a/src/whop_sdk/resources/courses.py +++ b/src/whop_sdk/resources/courses.py @@ -29,6 +29,8 @@ class CoursesResource(SyncAPIResource): + """Courses""" + @cached_property def with_raw_response(self) -> CoursesResourceWithRawResponse: """ @@ -359,6 +361,8 @@ def delete( class AsyncCoursesResource(AsyncAPIResource): + """Courses""" + @cached_property def with_raw_response(self) -> AsyncCoursesResourceWithRawResponse: """ diff --git a/src/whop_sdk/resources/dispute_alerts.py b/src/whop_sdk/resources/dispute_alerts.py index 03b47ef2..6ce07f13 100644 --- a/src/whop_sdk/resources/dispute_alerts.py +++ b/src/whop_sdk/resources/dispute_alerts.py @@ -28,6 +28,8 @@ class DisputeAlertsResource(SyncAPIResource): + """Dispute alerts""" + @cached_property def with_raw_response(self) -> DisputeAlertsResourceWithRawResponse: """ @@ -169,6 +171,8 @@ def list( class AsyncDisputeAlertsResource(AsyncAPIResource): + """Dispute alerts""" + @cached_property def with_raw_response(self) -> AsyncDisputeAlertsResourceWithRawResponse: """ diff --git a/src/whop_sdk/resources/disputes.py b/src/whop_sdk/resources/disputes.py index 0baa88dc..33d308f8 100644 --- a/src/whop_sdk/resources/disputes.py +++ b/src/whop_sdk/resources/disputes.py @@ -28,6 +28,8 @@ class DisputesResource(SyncAPIResource): + """Disputes""" + @cached_property def with_raw_response(self) -> DisputesResourceWithRawResponse: """ @@ -328,6 +330,8 @@ def update_evidence( class AsyncDisputesResource(AsyncAPIResource): + """Disputes""" + @cached_property def with_raw_response(self) -> AsyncDisputesResourceWithRawResponse: """ diff --git a/src/whop_sdk/resources/dm_channels.py b/src/whop_sdk/resources/dm_channels.py index 7e51c55e..6c979300 100644 --- a/src/whop_sdk/resources/dm_channels.py +++ b/src/whop_sdk/resources/dm_channels.py @@ -27,6 +27,8 @@ class DmChannelsResource(SyncAPIResource): + """Dm channels""" + @cached_property def with_raw_response(self) -> DmChannelsResourceWithRawResponse: """ @@ -282,6 +284,8 @@ def delete( class AsyncDmChannelsResource(AsyncAPIResource): + """Dm channels""" + @cached_property def with_raw_response(self) -> AsyncDmChannelsResourceWithRawResponse: """ diff --git a/src/whop_sdk/resources/dm_members.py b/src/whop_sdk/resources/dm_members.py index f1a8ca12..1681c01b 100644 --- a/src/whop_sdk/resources/dm_members.py +++ b/src/whop_sdk/resources/dm_members.py @@ -35,6 +35,8 @@ class DmMembersResource(SyncAPIResource): + """Dm members""" + @cached_property def with_raw_response(self) -> DmMembersResourceWithRawResponse: """ @@ -297,6 +299,8 @@ def delete( class AsyncDmMembersResource(AsyncAPIResource): + """Dm members""" + @cached_property def with_raw_response(self) -> AsyncDmMembersResourceWithRawResponse: """ diff --git a/src/whop_sdk/resources/entries.py b/src/whop_sdk/resources/entries.py index 41d5d23c..42e4218f 100644 --- a/src/whop_sdk/resources/entries.py +++ b/src/whop_sdk/resources/entries.py @@ -31,6 +31,8 @@ class EntriesResource(SyncAPIResource): + """Entries""" + @cached_property def with_raw_response(self) -> EntriesResourceWithRawResponse: """ @@ -261,6 +263,8 @@ def deny( class AsyncEntriesResource(AsyncAPIResource): + """Entries""" + @cached_property def with_raw_response(self) -> AsyncEntriesResourceWithRawResponse: """ diff --git a/src/whop_sdk/resources/experiences.py b/src/whop_sdk/resources/experiences.py index 50542d1d..531a200e 100644 --- a/src/whop_sdk/resources/experiences.py +++ b/src/whop_sdk/resources/experiences.py @@ -36,6 +36,8 @@ class ExperiencesResource(SyncAPIResource): + """Experiences""" + @cached_property def with_raw_response(self) -> ExperiencesResourceWithRawResponse: """ @@ -458,6 +460,8 @@ def duplicate( class AsyncExperiencesResource(AsyncAPIResource): + """Experiences""" + @cached_property def with_raw_response(self) -> AsyncExperiencesResourceWithRawResponse: """ diff --git a/src/whop_sdk/resources/fee_markups.py b/src/whop_sdk/resources/fee_markups.py index 9944dd2b..9a9e94ba 100644 --- a/src/whop_sdk/resources/fee_markups.py +++ b/src/whop_sdk/resources/fee_markups.py @@ -28,6 +28,8 @@ class FeeMarkupsResource(SyncAPIResource): + """Fee markups""" + @cached_property def with_raw_response(self) -> FeeMarkupsResourceWithRawResponse: """ @@ -219,6 +221,8 @@ def delete( class AsyncFeeMarkupsResource(AsyncAPIResource): + """Fee markups""" + @cached_property def with_raw_response(self) -> AsyncFeeMarkupsResourceWithRawResponse: """ diff --git a/src/whop_sdk/resources/files.py b/src/whop_sdk/resources/files.py index 5729ec7c..d481f6e8 100644 --- a/src/whop_sdk/resources/files.py +++ b/src/whop_sdk/resources/files.py @@ -23,6 +23,8 @@ class FilesResource(SyncAPIResource): + """Files""" + @cached_property def with_raw_response(self) -> FilesResourceWithRawResponse: """ @@ -113,6 +115,8 @@ def retrieve( class AsyncFilesResource(AsyncAPIResource): + """Files""" + @cached_property def with_raw_response(self) -> AsyncFilesResourceWithRawResponse: """ diff --git a/src/whop_sdk/resources/forum_posts.py b/src/whop_sdk/resources/forum_posts.py index 0acb986e..589c172d 100644 --- a/src/whop_sdk/resources/forum_posts.py +++ b/src/whop_sdk/resources/forum_posts.py @@ -33,6 +33,8 @@ class ForumPostsResource(SyncAPIResource): + """Forum posts""" + @cached_property def with_raw_response(self) -> ForumPostsResourceWithRawResponse: """ @@ -65,6 +67,7 @@ def create( paywall_currency: Optional[Currency] | Omit = omit, pinned: Optional[bool] | Omit = omit, poll: Optional[forum_post_create_params.Poll] | Omit = omit, + rich_content: Optional[str] | Omit = omit, title: Optional[str] | Omit = omit, visibility: Optional[ForumPostVisibilityType] | Omit = omit, # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. @@ -113,6 +116,9 @@ def create( poll: A poll to attach to this post, allowing members to vote on options. + rich_content: The rich content of the post in Tiptap JSON format. When provided, takes + priority over the markdown content field for rendering. + title: The title of the post, displayed prominently at the top. Required for paywalled posts as it remains visible to non-purchasers. @@ -140,6 +146,7 @@ def create( "paywall_currency": paywall_currency, "pinned": pinned, "poll": poll, + "rich_content": rich_content, "title": title, "visibility": visibility, }, @@ -327,6 +334,8 @@ def list( class AsyncForumPostsResource(AsyncAPIResource): + """Forum posts""" + @cached_property def with_raw_response(self) -> AsyncForumPostsResourceWithRawResponse: """ @@ -359,6 +368,7 @@ async def create( paywall_currency: Optional[Currency] | Omit = omit, pinned: Optional[bool] | Omit = omit, poll: Optional[forum_post_create_params.Poll] | Omit = omit, + rich_content: Optional[str] | Omit = omit, title: Optional[str] | Omit = omit, visibility: Optional[ForumPostVisibilityType] | Omit = omit, # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. @@ -407,6 +417,9 @@ async def create( poll: A poll to attach to this post, allowing members to vote on options. + rich_content: The rich content of the post in Tiptap JSON format. When provided, takes + priority over the markdown content field for rendering. + title: The title of the post, displayed prominently at the top. Required for paywalled posts as it remains visible to non-purchasers. @@ -434,6 +447,7 @@ async def create( "paywall_currency": paywall_currency, "pinned": pinned, "poll": poll, + "rich_content": rich_content, "title": title, "visibility": visibility, }, diff --git a/src/whop_sdk/resources/forums.py b/src/whop_sdk/resources/forums.py index 3159079e..b4f9e476 100644 --- a/src/whop_sdk/resources/forums.py +++ b/src/whop_sdk/resources/forums.py @@ -29,6 +29,8 @@ class ForumsResource(SyncAPIResource): + """Forums""" + @cached_property def with_raw_response(self) -> ForumsResourceWithRawResponse: """ @@ -89,6 +91,7 @@ def update( self, id: str, *, + banner_image: Optional[forum_update_params.BannerImage] | Omit = omit, email_notification_preference: Optional[EmailNotificationPreferences] | Omit = omit, who_can_comment: Optional[WhoCanCommentTypes] | Omit = omit, who_can_post: Optional[WhoCanPostTypes] | Omit = omit, @@ -108,6 +111,9 @@ def update( - `forum:moderate` Args: + banner_image: The banner image displayed at the top of the forum page. Pass null to remove the + existing banner. + email_notification_preference: Email notification preference option for a forum feed who_can_comment: Who can comment on a forum feed @@ -128,6 +134,7 @@ def update( f"/forums/{id}", body=maybe_transform( { + "banner_image": banner_image, "email_notification_preference": email_notification_preference, "who_can_comment": who_can_comment, "who_can_post": who_can_post, @@ -211,6 +218,8 @@ def list( class AsyncForumsResource(AsyncAPIResource): + """Forums""" + @cached_property def with_raw_response(self) -> AsyncForumsResourceWithRawResponse: """ @@ -271,6 +280,7 @@ async def update( self, id: str, *, + banner_image: Optional[forum_update_params.BannerImage] | Omit = omit, email_notification_preference: Optional[EmailNotificationPreferences] | Omit = omit, who_can_comment: Optional[WhoCanCommentTypes] | Omit = omit, who_can_post: Optional[WhoCanPostTypes] | Omit = omit, @@ -290,6 +300,9 @@ async def update( - `forum:moderate` Args: + banner_image: The banner image displayed at the top of the forum page. Pass null to remove the + existing banner. + email_notification_preference: Email notification preference option for a forum feed who_can_comment: Who can comment on a forum feed @@ -310,6 +323,7 @@ async def update( f"/forums/{id}", body=await async_maybe_transform( { + "banner_image": banner_image, "email_notification_preference": email_notification_preference, "who_can_comment": who_can_comment, "who_can_post": who_can_post, diff --git a/src/whop_sdk/resources/invoices.py b/src/whop_sdk/resources/invoices.py index aec677fc..017fa401 100644 --- a/src/whop_sdk/resources/invoices.py +++ b/src/whop_sdk/resources/invoices.py @@ -32,6 +32,8 @@ class InvoicesResource(SyncAPIResource): + """Invoices""" + @cached_property def with_raw_response(self) -> InvoicesResourceWithRawResponse: """ @@ -81,7 +83,6 @@ def create( Required permissions: - `invoice:create` - - `plan:basic:read` Args: collection_method: How the invoice should be collected. Use charge_automatically to charge a stored @@ -155,7 +156,6 @@ def create( Required permissions: - `invoice:create` - - `plan:basic:read` Args: collection_method: How the invoice should be collected. Use charge_automatically to charge a stored @@ -229,7 +229,6 @@ def create( Required permissions: - `invoice:create` - - `plan:basic:read` Args: collection_method: How the invoice should be collected. Use charge_automatically to charge a stored @@ -302,7 +301,6 @@ def create( Required permissions: - `invoice:create` - - `plan:basic:read` Args: collection_method: How the invoice should be collected. Use charge_automatically to charge a stored @@ -422,7 +420,6 @@ def retrieve( Required permissions: - `invoice:basic:read` - - `plan:basic:read` Args: extra_headers: Send extra headers @@ -446,10 +443,10 @@ def retrieve( def list( self, *, - company_id: str, after: Optional[str] | Omit = omit, before: Optional[str] | Omit = omit, collection_methods: Optional[List[CollectionMethod]] | Omit = omit, + company_id: Optional[str] | Omit = omit, created_after: Union[str, datetime, None] | Omit = omit, created_before: Union[str, datetime, None] | Omit = omit, direction: Optional[Direction] | Omit = omit, @@ -472,17 +469,16 @@ def list( Required permissions: - `invoice:basic:read` - - `plan:basic:read` Args: - company_id: The unique identifier of the company to list invoices for. - after: Returns the elements in the list that come after the specified cursor. before: Returns the elements in the list that come before the specified cursor. collection_methods: Filter invoices by their collection method. + company_id: The unique identifier of the company to list invoices for. + created_after: Only return invoices created after this timestamp. created_before: Only return invoices created before this timestamp. @@ -518,10 +514,10 @@ def list( timeout=timeout, query=maybe_transform( { - "company_id": company_id, "after": after, "before": before, "collection_methods": collection_methods, + "company_id": company_id, "created_after": created_after, "created_before": created_before, "direction": direction, @@ -578,6 +574,8 @@ def void( class AsyncInvoicesResource(AsyncAPIResource): + """Invoices""" + @cached_property def with_raw_response(self) -> AsyncInvoicesResourceWithRawResponse: """ @@ -627,7 +625,6 @@ async def create( Required permissions: - `invoice:create` - - `plan:basic:read` Args: collection_method: How the invoice should be collected. Use charge_automatically to charge a stored @@ -701,7 +698,6 @@ async def create( Required permissions: - `invoice:create` - - `plan:basic:read` Args: collection_method: How the invoice should be collected. Use charge_automatically to charge a stored @@ -775,7 +771,6 @@ async def create( Required permissions: - `invoice:create` - - `plan:basic:read` Args: collection_method: How the invoice should be collected. Use charge_automatically to charge a stored @@ -848,7 +843,6 @@ async def create( Required permissions: - `invoice:create` - - `plan:basic:read` Args: collection_method: How the invoice should be collected. Use charge_automatically to charge a stored @@ -968,7 +962,6 @@ async def retrieve( Required permissions: - `invoice:basic:read` - - `plan:basic:read` Args: extra_headers: Send extra headers @@ -992,10 +985,10 @@ async def retrieve( def list( self, *, - company_id: str, after: Optional[str] | Omit = omit, before: Optional[str] | Omit = omit, collection_methods: Optional[List[CollectionMethod]] | Omit = omit, + company_id: Optional[str] | Omit = omit, created_after: Union[str, datetime, None] | Omit = omit, created_before: Union[str, datetime, None] | Omit = omit, direction: Optional[Direction] | Omit = omit, @@ -1018,17 +1011,16 @@ def list( Required permissions: - `invoice:basic:read` - - `plan:basic:read` Args: - company_id: The unique identifier of the company to list invoices for. - after: Returns the elements in the list that come after the specified cursor. before: Returns the elements in the list that come before the specified cursor. collection_methods: Filter invoices by their collection method. + company_id: The unique identifier of the company to list invoices for. + created_after: Only return invoices created after this timestamp. created_before: Only return invoices created before this timestamp. @@ -1064,10 +1056,10 @@ def list( timeout=timeout, query=maybe_transform( { - "company_id": company_id, "after": after, "before": before, "collection_methods": collection_methods, + "company_id": company_id, "created_after": created_after, "created_before": created_before, "direction": direction, diff --git a/src/whop_sdk/resources/leads.py b/src/whop_sdk/resources/leads.py index df6f9929..fd31d3d3 100644 --- a/src/whop_sdk/resources/leads.py +++ b/src/whop_sdk/resources/leads.py @@ -27,6 +27,8 @@ class LeadsResource(SyncAPIResource): + """Leads""" + @cached_property def with_raw_response(self) -> LeadsResourceWithRawResponse: """ @@ -288,6 +290,8 @@ def list( class AsyncLeadsResource(AsyncAPIResource): + """Leads""" + @cached_property def with_raw_response(self) -> AsyncLeadsResourceWithRawResponse: """ diff --git a/src/whop_sdk/resources/ledger_accounts.py b/src/whop_sdk/resources/ledger_accounts.py index d213b5ca..cbbc4ee6 100644 --- a/src/whop_sdk/resources/ledger_accounts.py +++ b/src/whop_sdk/resources/ledger_accounts.py @@ -20,6 +20,8 @@ class LedgerAccountsResource(SyncAPIResource): + """Ledger accounts""" + @cached_property def with_raw_response(self) -> LedgerAccountsResourceWithRawResponse: """ @@ -79,6 +81,8 @@ def retrieve( class AsyncLedgerAccountsResource(AsyncAPIResource): + """Ledger accounts""" + @cached_property def with_raw_response(self) -> AsyncLedgerAccountsResourceWithRawResponse: """ diff --git a/src/whop_sdk/resources/members.py b/src/whop_sdk/resources/members.py index 811f248f..a9d50568 100644 --- a/src/whop_sdk/resources/members.py +++ b/src/whop_sdk/resources/members.py @@ -32,6 +32,8 @@ class MembersResource(SyncAPIResource): + """Members""" + @cached_property def with_raw_response(self) -> MembersResourceWithRawResponse: """ @@ -208,6 +210,8 @@ def list( class AsyncMembersResource(AsyncAPIResource): + """Members""" + @cached_property def with_raw_response(self) -> AsyncMembersResourceWithRawResponse: """ diff --git a/src/whop_sdk/resources/memberships.py b/src/whop_sdk/resources/memberships.py index 22af0afb..bf123a17 100644 --- a/src/whop_sdk/resources/memberships.py +++ b/src/whop_sdk/resources/memberships.py @@ -13,6 +13,7 @@ membership_pause_params, membership_cancel_params, membership_update_params, + membership_add_free_days_params, ) from .._types import Body, Omit, Query, Headers, NotGiven, SequenceNotStr, omit, not_given from .._utils import maybe_transform, async_maybe_transform @@ -36,6 +37,8 @@ class MembershipsResource(SyncAPIResource): + """Memberships""" + @cached_property def with_raw_response(self) -> MembershipsResourceWithRawResponse: """ @@ -244,6 +247,51 @@ def list( model=MembershipListResponse, ) + def add_free_days( + self, + id: str, + *, + free_days: int, + # 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, + ) -> Membership: + """ + Add free days to extend a membership's current billing period, expiration date, + or Stripe trial. + + Required permissions: + + - `member:manage` + - `member:email:read` + - `member:basic:read` + + Args: + free_days: The number of free days to add (1-1095). Extends the billing period, expiration + date, or Stripe trial depending on plan type. + + 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 id: + raise ValueError(f"Expected a non-empty value for `id` but received {id!r}") + return self._post( + f"/memberships/{id}/add_free_days", + body=maybe_transform({"free_days": free_days}, membership_add_free_days_params.MembershipAddFreeDaysParams), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=Membership, + ) + def cancel( self, id: str, @@ -262,7 +310,7 @@ def cancel( Required permissions: - - `member:manage` + - `membership:cancel` - `member:email:read` - `member:basic:read` @@ -419,6 +467,8 @@ def uncancel( class AsyncMembershipsResource(AsyncAPIResource): + """Memberships""" + @cached_property def with_raw_response(self) -> AsyncMembershipsResourceWithRawResponse: """ @@ -627,6 +677,53 @@ def list( model=MembershipListResponse, ) + async def add_free_days( + self, + id: str, + *, + free_days: int, + # 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, + ) -> Membership: + """ + Add free days to extend a membership's current billing period, expiration date, + or Stripe trial. + + Required permissions: + + - `member:manage` + - `member:email:read` + - `member:basic:read` + + Args: + free_days: The number of free days to add (1-1095). Extends the billing period, expiration + date, or Stripe trial depending on plan type. + + 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 id: + raise ValueError(f"Expected a non-empty value for `id` but received {id!r}") + return await self._post( + f"/memberships/{id}/add_free_days", + body=await async_maybe_transform( + {"free_days": free_days}, membership_add_free_days_params.MembershipAddFreeDaysParams + ), + options=make_request_options( + extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout + ), + cast_to=Membership, + ) + async def cancel( self, id: str, @@ -645,7 +742,7 @@ async def cancel( Required permissions: - - `member:manage` + - `membership:cancel` - `member:email:read` - `member:basic:read` @@ -816,6 +913,9 @@ def __init__(self, memberships: MembershipsResource) -> None: self.list = to_raw_response_wrapper( memberships.list, ) + self.add_free_days = to_raw_response_wrapper( + memberships.add_free_days, + ) self.cancel = to_raw_response_wrapper( memberships.cancel, ) @@ -843,6 +943,9 @@ def __init__(self, memberships: AsyncMembershipsResource) -> None: self.list = async_to_raw_response_wrapper( memberships.list, ) + self.add_free_days = async_to_raw_response_wrapper( + memberships.add_free_days, + ) self.cancel = async_to_raw_response_wrapper( memberships.cancel, ) @@ -870,6 +973,9 @@ def __init__(self, memberships: MembershipsResource) -> None: self.list = to_streamed_response_wrapper( memberships.list, ) + self.add_free_days = to_streamed_response_wrapper( + memberships.add_free_days, + ) self.cancel = to_streamed_response_wrapper( memberships.cancel, ) @@ -897,6 +1003,9 @@ def __init__(self, memberships: AsyncMembershipsResource) -> None: self.list = async_to_streamed_response_wrapper( memberships.list, ) + self.add_free_days = async_to_streamed_response_wrapper( + memberships.add_free_days, + ) self.cancel = async_to_streamed_response_wrapper( memberships.cancel, ) diff --git a/src/whop_sdk/resources/messages.py b/src/whop_sdk/resources/messages.py index 73316027..06ba3f0b 100644 --- a/src/whop_sdk/resources/messages.py +++ b/src/whop_sdk/resources/messages.py @@ -28,6 +28,8 @@ class MessagesResource(SyncAPIResource): + """Messages""" + @cached_property def with_raw_response(self) -> MessagesResourceWithRawResponse: """ @@ -313,6 +315,8 @@ def delete( class AsyncMessagesResource(AsyncAPIResource): + """Messages""" + @cached_property def with_raw_response(self) -> AsyncMessagesResourceWithRawResponse: """ diff --git a/src/whop_sdk/resources/notifications.py b/src/whop_sdk/resources/notifications.py index f1eff29a..eaf1c066 100644 --- a/src/whop_sdk/resources/notifications.py +++ b/src/whop_sdk/resources/notifications.py @@ -25,6 +25,8 @@ class NotificationsResource(SyncAPIResource): + """Notifications""" + @cached_property def with_raw_response(self) -> NotificationsResourceWithRawResponse: """ @@ -208,6 +210,8 @@ def create( class AsyncNotificationsResource(AsyncAPIResource): + """Notifications""" + @cached_property def with_raw_response(self) -> AsyncNotificationsResourceWithRawResponse: """ diff --git a/src/whop_sdk/resources/payment_methods.py b/src/whop_sdk/resources/payment_methods.py index 9e993655..9e9da3d2 100644 --- a/src/whop_sdk/resources/payment_methods.py +++ b/src/whop_sdk/resources/payment_methods.py @@ -28,6 +28,8 @@ class PaymentMethodsResource(SyncAPIResource): + """Payment methods""" + @cached_property def with_raw_response(self) -> PaymentMethodsResourceWithRawResponse: """ @@ -194,6 +196,8 @@ def list( class AsyncPaymentMethodsResource(AsyncAPIResource): + """Payment methods""" + @cached_property def with_raw_response(self) -> AsyncPaymentMethodsResourceWithRawResponse: """ diff --git a/src/whop_sdk/resources/payments.py b/src/whop_sdk/resources/payments.py index d36041da..47e0be4c 100644 --- a/src/whop_sdk/resources/payments.py +++ b/src/whop_sdk/resources/payments.py @@ -34,6 +34,8 @@ class PaymentsResource(SyncAPIResource): + """Payments""" + @cached_property def with_raw_response(self) -> PaymentsResourceWithRawResponse: """ @@ -588,6 +590,8 @@ def void( class AsyncPaymentsResource(AsyncAPIResource): + """Payments""" + @cached_property def with_raw_response(self) -> AsyncPaymentsResourceWithRawResponse: """ diff --git a/src/whop_sdk/resources/payout_methods.py b/src/whop_sdk/resources/payout_methods.py index 0333f57e..d0c5978d 100644 --- a/src/whop_sdk/resources/payout_methods.py +++ b/src/whop_sdk/resources/payout_methods.py @@ -26,6 +26,8 @@ class PayoutMethodsResource(SyncAPIResource): + """Payout methods""" + @cached_property def with_raw_response(self) -> PayoutMethodsResourceWithRawResponse: """ @@ -148,6 +150,8 @@ def list( class AsyncPayoutMethodsResource(AsyncAPIResource): + """Payout methods""" + @cached_property def with_raw_response(self) -> AsyncPayoutMethodsResourceWithRawResponse: """ diff --git a/src/whop_sdk/resources/plans.py b/src/whop_sdk/resources/plans.py index 413c3f89..fbd116c4 100644 --- a/src/whop_sdk/resources/plans.py +++ b/src/whop_sdk/resources/plans.py @@ -36,6 +36,8 @@ class PlansResource(SyncAPIResource): + """Plans""" + @cached_property def with_raw_response(self) -> PlansResourceWithRawResponse: """ @@ -504,6 +506,8 @@ def delete( class AsyncPlansResource(AsyncAPIResource): + """Plans""" + @cached_property def with_raw_response(self) -> AsyncPlansResourceWithRawResponse: """ diff --git a/src/whop_sdk/resources/products.py b/src/whop_sdk/resources/products.py index a4b6793a..0c34deb9 100644 --- a/src/whop_sdk/resources/products.py +++ b/src/whop_sdk/resources/products.py @@ -35,6 +35,8 @@ class ProductsResource(SyncAPIResource): + """Products""" + @cached_property def with_raw_response(self) -> ProductsResourceWithRawResponse: """ @@ -453,6 +455,8 @@ def delete( class AsyncProductsResource(AsyncAPIResource): + """Products""" + @cached_property def with_raw_response(self) -> AsyncProductsResourceWithRawResponse: """ diff --git a/src/whop_sdk/resources/promo_codes.py b/src/whop_sdk/resources/promo_codes.py index 4d8deb2f..5bb3b5d3 100644 --- a/src/whop_sdk/resources/promo_codes.py +++ b/src/whop_sdk/resources/promo_codes.py @@ -31,6 +31,8 @@ class PromoCodesResource(SyncAPIResource): + """Promo codes""" + @cached_property def with_raw_response(self) -> PromoCodesResourceWithRawResponse: """ @@ -325,6 +327,8 @@ def delete( class AsyncPromoCodesResource(AsyncAPIResource): + """Promo codes""" + @cached_property def with_raw_response(self) -> AsyncPromoCodesResourceWithRawResponse: """ diff --git a/src/whop_sdk/resources/reactions.py b/src/whop_sdk/resources/reactions.py index 46882546..901f51a8 100644 --- a/src/whop_sdk/resources/reactions.py +++ b/src/whop_sdk/resources/reactions.py @@ -27,6 +27,8 @@ class ReactionsResource(SyncAPIResource): + """Reactions""" + @cached_property def with_raw_response(self) -> ReactionsResourceWithRawResponse: """ @@ -252,6 +254,8 @@ def delete( class AsyncReactionsResource(AsyncAPIResource): + """Reactions""" + @cached_property def with_raw_response(self) -> AsyncReactionsResourceWithRawResponse: """ diff --git a/src/whop_sdk/resources/refunds.py b/src/whop_sdk/resources/refunds.py index ed7ba09f..e9bc15a9 100644 --- a/src/whop_sdk/resources/refunds.py +++ b/src/whop_sdk/resources/refunds.py @@ -28,6 +28,8 @@ class RefundsResource(SyncAPIResource): + """Refunds""" + @cached_property def with_raw_response(self) -> RefundsResourceWithRawResponse: """ @@ -165,6 +167,8 @@ def list( class AsyncRefundsResource(AsyncAPIResource): + """Refunds""" + @cached_property def with_raw_response(self) -> AsyncRefundsResourceWithRawResponse: """ diff --git a/src/whop_sdk/resources/reviews.py b/src/whop_sdk/resources/reviews.py index 3ce2c4d7..096ed767 100644 --- a/src/whop_sdk/resources/reviews.py +++ b/src/whop_sdk/resources/reviews.py @@ -27,6 +27,8 @@ class ReviewsResource(SyncAPIResource): + """Reviews""" + @cached_property def with_raw_response(self) -> ReviewsResourceWithRawResponse: """ @@ -157,6 +159,8 @@ def list( class AsyncReviewsResource(AsyncAPIResource): + """Reviews""" + @cached_property def with_raw_response(self) -> AsyncReviewsResourceWithRawResponse: """ diff --git a/src/whop_sdk/resources/setup_intents.py b/src/whop_sdk/resources/setup_intents.py index e85baf44..71e5989c 100644 --- a/src/whop_sdk/resources/setup_intents.py +++ b/src/whop_sdk/resources/setup_intents.py @@ -28,6 +28,8 @@ class SetupIntentsResource(SyncAPIResource): + """Setup intents""" + @cached_property def with_raw_response(self) -> SetupIntentsResourceWithRawResponse: """ @@ -167,6 +169,8 @@ def list( class AsyncSetupIntentsResource(AsyncAPIResource): + """Setup intents""" + @cached_property def with_raw_response(self) -> AsyncSetupIntentsResourceWithRawResponse: """ diff --git a/src/whop_sdk/resources/shipments.py b/src/whop_sdk/resources/shipments.py index 1b46c631..e6b88fe8 100644 --- a/src/whop_sdk/resources/shipments.py +++ b/src/whop_sdk/resources/shipments.py @@ -26,6 +26,8 @@ class ShipmentsResource(SyncAPIResource): + """Shipments""" + @cached_property def with_raw_response(self) -> ShipmentsResourceWithRawResponse: """ @@ -213,6 +215,8 @@ def list( class AsyncShipmentsResource(AsyncAPIResource): + """Shipments""" + @cached_property def with_raw_response(self) -> AsyncShipmentsResourceWithRawResponse: """ diff --git a/src/whop_sdk/resources/support_channels.py b/src/whop_sdk/resources/support_channels.py index 7b5146ae..4fba5053 100644 --- a/src/whop_sdk/resources/support_channels.py +++ b/src/whop_sdk/resources/support_channels.py @@ -28,6 +28,8 @@ class SupportChannelsResource(SyncAPIResource): + """Support channels""" + @cached_property def with_raw_response(self) -> SupportChannelsResourceWithRawResponse: """ @@ -217,6 +219,8 @@ def list( class AsyncSupportChannelsResource(AsyncAPIResource): + """Support channels""" + @cached_property def with_raw_response(self) -> AsyncSupportChannelsResourceWithRawResponse: """ diff --git a/src/whop_sdk/resources/topups.py b/src/whop_sdk/resources/topups.py index 858cd891..8dd55658 100644 --- a/src/whop_sdk/resources/topups.py +++ b/src/whop_sdk/resources/topups.py @@ -23,6 +23,8 @@ class TopupsResource(SyncAPIResource): + """Topups""" + @cached_property def with_raw_response(self) -> TopupsResourceWithRawResponse: """ @@ -101,6 +103,8 @@ def create( class AsyncTopupsResource(AsyncAPIResource): + """Topups""" + @cached_property def with_raw_response(self) -> AsyncTopupsResourceWithRawResponse: """ diff --git a/src/whop_sdk/resources/transfers.py b/src/whop_sdk/resources/transfers.py index 6252141a..9837e10c 100644 --- a/src/whop_sdk/resources/transfers.py +++ b/src/whop_sdk/resources/transfers.py @@ -30,6 +30,8 @@ class TransfersResource(SyncAPIResource): + """Transfers""" + @cached_property def with_raw_response(self) -> TransfersResourceWithRawResponse: """ @@ -247,6 +249,8 @@ def list( class AsyncTransfersResource(AsyncAPIResource): + """Transfers""" + @cached_property def with_raw_response(self) -> AsyncTransfersResourceWithRawResponse: """ diff --git a/src/whop_sdk/resources/users.py b/src/whop_sdk/resources/users.py index 914efd00..4d01d560 100644 --- a/src/whop_sdk/resources/users.py +++ b/src/whop_sdk/resources/users.py @@ -25,6 +25,8 @@ class UsersResource(SyncAPIResource): + """Users""" + @cached_property def with_raw_response(self) -> UsersResourceWithRawResponse: """ @@ -172,6 +174,8 @@ def update_profile( class AsyncUsersResource(AsyncAPIResource): + """Users""" + @cached_property def with_raw_response(self) -> AsyncUsersResourceWithRawResponse: """ diff --git a/src/whop_sdk/resources/verifications.py b/src/whop_sdk/resources/verifications.py index 02f4b65d..829e8aa5 100644 --- a/src/whop_sdk/resources/verifications.py +++ b/src/whop_sdk/resources/verifications.py @@ -20,6 +20,8 @@ class VerificationsResource(SyncAPIResource): + """Verifications""" + @cached_property def with_raw_response(self) -> VerificationsResourceWithRawResponse: """ @@ -78,6 +80,8 @@ def retrieve( class AsyncVerificationsResource(AsyncAPIResource): + """Verifications""" + @cached_property def with_raw_response(self) -> AsyncVerificationsResourceWithRawResponse: """ diff --git a/src/whop_sdk/resources/webhooks.py b/src/whop_sdk/resources/webhooks.py index 340e6a65..b396c301 100644 --- a/src/whop_sdk/resources/webhooks.py +++ b/src/whop_sdk/resources/webhooks.py @@ -34,6 +34,8 @@ class WebhooksResource(SyncAPIResource): + """Webhooks""" + @cached_property def with_raw_response(self) -> WebhooksResourceWithRawResponse: """ @@ -346,6 +348,8 @@ def unwrap(self, payload: str, *, headers: Mapping[str, str], key: str | bytes | class AsyncWebhooksResource(AsyncAPIResource): + """Webhooks""" + @cached_property def with_raw_response(self) -> AsyncWebhooksResourceWithRawResponse: """ diff --git a/src/whop_sdk/resources/withdrawals.py b/src/whop_sdk/resources/withdrawals.py index 51b74257..3e6895cb 100644 --- a/src/whop_sdk/resources/withdrawals.py +++ b/src/whop_sdk/resources/withdrawals.py @@ -29,6 +29,8 @@ class WithdrawalsResource(SyncAPIResource): + """Withdrawals""" + @cached_property def with_raw_response(self) -> WithdrawalsResourceWithRawResponse: """ @@ -229,6 +231,8 @@ def list( class AsyncWithdrawalsResource(AsyncAPIResource): + """Withdrawals""" + @cached_property def with_raw_response(self) -> AsyncWithdrawalsResourceWithRawResponse: """ diff --git a/src/whop_sdk/types/__init__.py b/src/whop_sdk/types/__init__.py index 6d305f1a..c2af8893 100644 --- a/src/whop_sdk/types/__init__.py +++ b/src/whop_sdk/types/__init__.py @@ -139,9 +139,11 @@ from .payment_method_types import PaymentMethodTypes as PaymentMethodTypes from .plan_delete_response import PlanDeleteResponse as PlanDeleteResponse from .reaction_list_params import ReactionListParams as ReactionListParams +from .receipt_tax_behavior import ReceiptTaxBehavior as ReceiptTaxBehavior from .refund_list_response import RefundListResponse as RefundListResponse from .review_list_response import ReviewListResponse as ReviewListResponse from .shipment_list_params import ShipmentListParams as ShipmentListParams +from .social_link_websites import SocialLinkWebsites as SocialLinkWebsites from .transfer_list_params import TransferListParams as TransferListParams from .unwrap_webhook_event import UnwrapWebhookEvent as UnwrapWebhookEvent from .withdrawal_fee_types import WithdrawalFeeTypes as WithdrawalFeeTypes @@ -278,6 +280,8 @@ from .payment_method_list_response import PaymentMethodListResponse as PaymentMethodListResponse from .refund_created_webhook_event import RefundCreatedWebhookEvent as RefundCreatedWebhookEvent from .refund_updated_webhook_event import RefundUpdatedWebhookEvent as RefundUpdatedWebhookEvent +from .authorized_user_create_params import AuthorizedUserCreateParams as AuthorizedUserCreateParams +from .authorized_user_delete_params import AuthorizedUserDeleteParams as AuthorizedUserDeleteParams from .authorized_user_list_response import AuthorizedUserListResponse as AuthorizedUserListResponse from .course_lesson_delete_response import CourseLessonDeleteResponse as CourseLessonDeleteResponse from .dispute_created_webhook_event import DisputeCreatedWebhookEvent as DisputeCreatedWebhookEvent @@ -293,7 +297,10 @@ from .invoice_past_due_webhook_event import InvoicePastDueWebhookEvent as InvoicePastDueWebhookEvent from .payment_method_retrieve_params import PaymentMethodRetrieveParams as PaymentMethodRetrieveParams from .verification_retrieve_response import VerificationRetrieveResponse as VerificationRetrieveResponse +from .authorized_user_create_response import AuthorizedUserCreateResponse as AuthorizedUserCreateResponse +from .authorized_user_delete_response import AuthorizedUserDeleteResponse as AuthorizedUserDeleteResponse from .dispute_alert_retrieve_response import DisputeAlertRetrieveResponse as DisputeAlertRetrieveResponse +from .membership_add_free_days_params import MembershipAddFreeDaysParams as MembershipAddFreeDaysParams from .payment_succeeded_webhook_event import PaymentSucceededWebhookEvent as PaymentSucceededWebhookEvent from .payout_method_retrieve_response import PayoutMethodRetrieveResponse as PayoutMethodRetrieveResponse from .course_student_retrieve_response import CourseStudentRetrieveResponse as CourseStudentRetrieveResponse diff --git a/src/whop_sdk/types/ai_chat_create_params.py b/src/whop_sdk/types/ai_chat_create_params.py index 9b147c0e..4eee3a32 100644 --- a/src/whop_sdk/types/ai_chat_create_params.py +++ b/src/whop_sdk/types/ai_chat_create_params.py @@ -27,6 +27,12 @@ class AIChatCreateParams(TypedDict, total=False): message_source: Optional[Literal["manual", "suggestion", "link"]] """The source of an AI chat message""" + suggestion_type: Optional[str] + """ + The type of suggestion prompt that was clicked, when message_source is + 'suggestion'. + """ + title: Optional[str] """An optional display title for the AI chat thread (e.g., "Help with billing").""" diff --git a/src/whop_sdk/types/authorized_user_create_params.py b/src/whop_sdk/types/authorized_user_create_params.py new file mode 100644 index 00000000..b2b538a5 --- /dev/null +++ b/src/whop_sdk/types/authorized_user_create_params.py @@ -0,0 +1,27 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Optional +from typing_extensions import Required, TypedDict + +from .shared.authorized_user_roles import AuthorizedUserRoles + +__all__ = ["AuthorizedUserCreateParams"] + + +class AuthorizedUserCreateParams(TypedDict, total=False): + company_id: Required[str] + """The ID of the company to add the authorized user to.""" + + role: Required[AuthorizedUserRoles] + """The role to assign to the authorized user within the company. + + Supported roles: 'moderator', 'sales_manager'. + """ + + user_id: Required[str] + """The ID of the user to add as an authorized user.""" + + send_emails: Optional[bool] + """Whether to send notification emails to the user on creation.""" diff --git a/src/whop_sdk/types/authorized_user_create_response.py b/src/whop_sdk/types/authorized_user_create_response.py new file mode 100644 index 00000000..1bf69abd --- /dev/null +++ b/src/whop_sdk/types/authorized_user_create_response.py @@ -0,0 +1,55 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing import Optional + +from .._models import BaseModel +from .shared.authorized_user_roles import AuthorizedUserRoles + +__all__ = ["AuthorizedUserCreateResponse", "Company", "User"] + + +class Company(BaseModel): + """The company this authorized user has access to.""" + + id: str + """The unique identifier for the company.""" + + title: str + """The display name of the company shown to customers.""" + + +class User(BaseModel): + """The user account linked to this authorized user record.""" + + id: str + """The unique identifier for the user.""" + + email: Optional[str] = None + """The user's email address. + + Requires the member:email:read permission to access. Null if not authorized. + """ + + name: Optional[str] = None + """The user's display name shown on their public profile.""" + + username: str + """The user's unique username shown on their public profile.""" + + +class AuthorizedUserCreateResponse(BaseModel): + """ + A user who has been granted administrative access to manage a company's dashboard and settings. + """ + + id: str + """The unique identifier for the authorized user.""" + + company: Company + """The company this authorized user has access to.""" + + role: AuthorizedUserRoles + """The permission role assigned to this authorized user within the company.""" + + user: User + """The user account linked to this authorized user record.""" diff --git a/src/whop_sdk/types/authorized_user_delete_params.py b/src/whop_sdk/types/authorized_user_delete_params.py new file mode 100644 index 00000000..ead84a1b --- /dev/null +++ b/src/whop_sdk/types/authorized_user_delete_params.py @@ -0,0 +1,16 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing import Optional +from typing_extensions import TypedDict + +__all__ = ["AuthorizedUserDeleteParams"] + + +class AuthorizedUserDeleteParams(TypedDict, total=False): + company_id: Optional[str] + """The ID of the company the authorized user belongs to. + + Optional if the authorized user ID is provided. + """ diff --git a/src/whop_sdk/types/authorized_user_delete_response.py b/src/whop_sdk/types/authorized_user_delete_response.py new file mode 100644 index 00000000..b71b66f0 --- /dev/null +++ b/src/whop_sdk/types/authorized_user_delete_response.py @@ -0,0 +1,7 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing_extensions import TypeAlias + +__all__ = ["AuthorizedUserDeleteResponse"] + +AuthorizedUserDeleteResponse: TypeAlias = bool diff --git a/src/whop_sdk/types/company_update_params.py b/src/whop_sdk/types/company_update_params.py index c475d5fb..089fdafe 100644 --- a/src/whop_sdk/types/company_update_params.py +++ b/src/whop_sdk/types/company_update_params.py @@ -2,10 +2,12 @@ from __future__ import annotations -from typing import Optional +from typing import Iterable, Optional from typing_extensions import Required, TypedDict -__all__ = ["CompanyUpdateParams", "BannerImage", "Logo"] +from .social_link_websites import SocialLinkWebsites + +__all__ = ["CompanyUpdateParams", "BannerImage", "Logo", "SocialLink", "SocialLinkImage"] class CompanyUpdateParams(TypedDict, total=False): @@ -34,6 +36,13 @@ class CompanyUpdateParams(TypedDict, total=False): customers on behalf of this company. """ + social_links: Optional[Iterable[SocialLink]] + """The social media links to display on the company's store page. + + Pass the full list of desired social links — any existing links not included + will be removed. + """ + target_audience: Optional[str] """ The target audience for this company (e.g., 'beginner day traders aged 18-25 @@ -56,3 +65,32 @@ class Logo(TypedDict, total=False): id: Required[str] """The ID of an existing file object.""" + + +class SocialLinkImage(TypedDict, total=False): + """The custom image for the social link""" + + id: Required[str] + """The ID of an existing file object.""" + + +class SocialLink(TypedDict, total=False): + """Input for creating a social link for a company""" + + url: Required[str] + """The URL of the social link""" + + website: Required[SocialLinkWebsites] + """The website this link is for""" + + image: Optional[SocialLinkImage] + """The custom image for the social link""" + + order: Optional[str] + """The order of the social link""" + + title: Optional[str] + """The title of the social link""" + + website_order: Optional[str] + """The order of the website social link""" diff --git a/src/whop_sdk/types/forum_post_create_params.py b/src/whop_sdk/types/forum_post_create_params.py index 217521fc..6b8281a8 100644 --- a/src/whop_sdk/types/forum_post_create_params.py +++ b/src/whop_sdk/types/forum_post_create_params.py @@ -63,6 +63,12 @@ class ForumPostCreateParams(TypedDict, total=False): poll: Optional[Poll] """A poll to attach to this post, allowing members to vote on options.""" + rich_content: Optional[str] + """The rich content of the post in Tiptap JSON format. + + When provided, takes priority over the markdown content field for rendering. + """ + title: Optional[str] """The title of the post, displayed prominently at the top. diff --git a/src/whop_sdk/types/forum_post_list_response.py b/src/whop_sdk/types/forum_post_list_response.py index 4bb4f301..4cbd7083 100644 --- a/src/whop_sdk/types/forum_post_list_response.py +++ b/src/whop_sdk/types/forum_post_list_response.py @@ -1,11 +1,37 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. -from typing import Optional +from typing import List, Optional from datetime import datetime from .._models import BaseModel -__all__ = ["ForumPostListResponse", "User"] +__all__ = ["ForumPostListResponse", "Attachment", "User"] + + +class Attachment(BaseModel): + """Represents an image attachment""" + + id: str + """Represents a unique identifier that is Base64 obfuscated. + + It is often used to refetch an object or as key for a cache. The ID type appears + in a JSON response as a String; however, it is not intended to be + human-readable. When expected as an input type, any string (such as + `"VXNlci0xMA=="`) or integer (such as `4`) input value will be accepted as an + ID. + """ + + content_type: Optional[str] = None + """The MIME type of the uploaded file (e.g., image/jpeg, video/mp4, audio/mpeg).""" + + filename: Optional[str] = None + """The original filename of the uploaded attachment, including its file extension.""" + + url: Optional[str] = None + """A pre-optimized URL for rendering this attachment on the client. + + This should be used for displaying attachments in apps. + """ class User(BaseModel): @@ -36,6 +62,9 @@ class ForumPostListResponse(BaseModel): ID. """ + attachments: List[Attachment] + """All file attachments on this post, such as images, documents, and videos.""" + comment_count: int """The total number of direct comments on this post.""" diff --git a/src/whop_sdk/types/forum_update_params.py b/src/whop_sdk/types/forum_update_params.py index 2e2a97bc..259496ec 100644 --- a/src/whop_sdk/types/forum_update_params.py +++ b/src/whop_sdk/types/forum_update_params.py @@ -3,16 +3,22 @@ from __future__ import annotations from typing import Optional -from typing_extensions import TypedDict +from typing_extensions import Required, TypedDict from .shared.who_can_post_types import WhoCanPostTypes from .shared.who_can_comment_types import WhoCanCommentTypes from .shared.email_notification_preferences import EmailNotificationPreferences -__all__ = ["ForumUpdateParams"] +__all__ = ["ForumUpdateParams", "BannerImage"] class ForumUpdateParams(TypedDict, total=False): + banner_image: Optional[BannerImage] + """The banner image displayed at the top of the forum page. + + Pass null to remove the existing banner. + """ + email_notification_preference: Optional[EmailNotificationPreferences] """Email notification preference option for a forum feed""" @@ -21,3 +27,13 @@ class ForumUpdateParams(TypedDict, total=False): who_can_post: Optional[WhoCanPostTypes] """Who can post on a forum feed""" + + +class BannerImage(TypedDict, total=False): + """The banner image displayed at the top of the forum page. + + Pass null to remove the existing banner. + """ + + id: Required[str] + """The ID of an existing file object.""" diff --git a/src/whop_sdk/types/invoice_create_params.py b/src/whop_sdk/types/invoice_create_params.py index a3c6104b..65c36fae 100644 --- a/src/whop_sdk/types/invoice_create_params.py +++ b/src/whop_sdk/types/invoice_create_params.py @@ -2,13 +2,14 @@ from __future__ import annotations -from typing import Union, Iterable, Optional +from typing import List, Union, Iterable, Optional from datetime import datetime from typing_extensions import Literal, Required, Annotated, TypeAlias, TypedDict from .._utils import PropertyInfo from .shared.plan_type import PlanType from .shared.visibility import Visibility +from .payment_method_types import PaymentMethodTypes from .shared.release_method import ReleaseMethod from .shared.collection_method import CollectionMethod @@ -17,17 +18,21 @@ "CreateInvoiceInputWithProductAndMemberID", "CreateInvoiceInputWithProductAndMemberIDPlan", "CreateInvoiceInputWithProductAndMemberIDPlanCustomField", + "CreateInvoiceInputWithProductAndMemberIDPlanPaymentMethodConfiguration", "CreateInvoiceInputWithProductAndMemberIDProduct", "CreateInvoiceInputWithProductAndEmailAddress", "CreateInvoiceInputWithProductAndEmailAddressPlan", "CreateInvoiceInputWithProductAndEmailAddressPlanCustomField", + "CreateInvoiceInputWithProductAndEmailAddressPlanPaymentMethodConfiguration", "CreateInvoiceInputWithProductAndEmailAddressProduct", "CreateInvoiceInputWithProductIDAndMemberID", "CreateInvoiceInputWithProductIDAndMemberIDPlan", "CreateInvoiceInputWithProductIDAndMemberIDPlanCustomField", + "CreateInvoiceInputWithProductIDAndMemberIDPlanPaymentMethodConfiguration", "CreateInvoiceInputWithProductIDAndEmailAddress", "CreateInvoiceInputWithProductIDAndEmailAddressPlan", "CreateInvoiceInputWithProductIDAndEmailAddressPlanCustomField", + "CreateInvoiceInputWithProductIDAndEmailAddressPlanPaymentMethodConfiguration", ] @@ -113,6 +118,34 @@ class CreateInvoiceInputWithProductAndMemberIDPlanCustomField(TypedDict, total=F """Whether or not the field is required.""" +class CreateInvoiceInputWithProductAndMemberIDPlanPaymentMethodConfiguration(TypedDict, total=False): + """The explicit payment method configuration for the plan. + + If not provided, the platform or company's defaults will apply. + """ + + disabled: Required[List[PaymentMethodTypes]] + """An array of payment method identifiers that are explicitly disabled. + + Only applies if the include_platform_defaults is true. + """ + + enabled: Required[List[PaymentMethodTypes]] + """An array of payment method identifiers that are explicitly enabled. + + This means these payment methods will be shown on checkout. Example use case is + to only enable a specific payment method like cashapp, or extending the platform + defaults with additional methods. + """ + + include_platform_defaults: Required[bool] + """ + Whether Whop's platform default payment method enablement settings are included + in this configuration. The full list of default payment methods can be found in + the documentation at docs.whop.com/payments. + """ + + class CreateInvoiceInputWithProductAndMemberIDPlan(TypedDict, total=False): """ The plan attributes defining the price, currency, and billing interval for this invoice. @@ -144,6 +177,15 @@ class CreateInvoiceInputWithProductAndMemberIDPlan(TypedDict, total=False): internal_notes: Optional[str] """A personal description or notes section for the business.""" + legacy_payment_method_controls: Optional[bool] + """Whether this plan uses legacy payment method controls""" + + payment_method_configuration: Optional[CreateInvoiceInputWithProductAndMemberIDPlanPaymentMethodConfiguration] + """The explicit payment method configuration for the plan. + + If not provided, the platform or company's defaults will apply. + """ + plan_type: Optional[PlanType] """The type of plan that can be attached to a product""" @@ -269,6 +311,34 @@ class CreateInvoiceInputWithProductAndEmailAddressPlanCustomField(TypedDict, tot """Whether or not the field is required.""" +class CreateInvoiceInputWithProductAndEmailAddressPlanPaymentMethodConfiguration(TypedDict, total=False): + """The explicit payment method configuration for the plan. + + If not provided, the platform or company's defaults will apply. + """ + + disabled: Required[List[PaymentMethodTypes]] + """An array of payment method identifiers that are explicitly disabled. + + Only applies if the include_platform_defaults is true. + """ + + enabled: Required[List[PaymentMethodTypes]] + """An array of payment method identifiers that are explicitly enabled. + + This means these payment methods will be shown on checkout. Example use case is + to only enable a specific payment method like cashapp, or extending the platform + defaults with additional methods. + """ + + include_platform_defaults: Required[bool] + """ + Whether Whop's platform default payment method enablement settings are included + in this configuration. The full list of default payment methods can be found in + the documentation at docs.whop.com/payments. + """ + + class CreateInvoiceInputWithProductAndEmailAddressPlan(TypedDict, total=False): """ The plan attributes defining the price, currency, and billing interval for this invoice. @@ -300,6 +370,15 @@ class CreateInvoiceInputWithProductAndEmailAddressPlan(TypedDict, total=False): internal_notes: Optional[str] """A personal description or notes section for the business.""" + legacy_payment_method_controls: Optional[bool] + """Whether this plan uses legacy payment method controls""" + + payment_method_configuration: Optional[CreateInvoiceInputWithProductAndEmailAddressPlanPaymentMethodConfiguration] + """The explicit payment method configuration for the plan. + + If not provided, the platform or company's defaults will apply. + """ + plan_type: Optional[PlanType] """The type of plan that can be attached to a product""" @@ -421,6 +500,34 @@ class CreateInvoiceInputWithProductIDAndMemberIDPlanCustomField(TypedDict, total """Whether or not the field is required.""" +class CreateInvoiceInputWithProductIDAndMemberIDPlanPaymentMethodConfiguration(TypedDict, total=False): + """The explicit payment method configuration for the plan. + + If not provided, the platform or company's defaults will apply. + """ + + disabled: Required[List[PaymentMethodTypes]] + """An array of payment method identifiers that are explicitly disabled. + + Only applies if the include_platform_defaults is true. + """ + + enabled: Required[List[PaymentMethodTypes]] + """An array of payment method identifiers that are explicitly enabled. + + This means these payment methods will be shown on checkout. Example use case is + to only enable a specific payment method like cashapp, or extending the platform + defaults with additional methods. + """ + + include_platform_defaults: Required[bool] + """ + Whether Whop's platform default payment method enablement settings are included + in this configuration. The full list of default payment methods can be found in + the documentation at docs.whop.com/payments. + """ + + class CreateInvoiceInputWithProductIDAndMemberIDPlan(TypedDict, total=False): """ The plan attributes defining the price, currency, and billing interval for this invoice. @@ -452,6 +559,15 @@ class CreateInvoiceInputWithProductIDAndMemberIDPlan(TypedDict, total=False): internal_notes: Optional[str] """A personal description or notes section for the business.""" + legacy_payment_method_controls: Optional[bool] + """Whether this plan uses legacy payment method controls""" + + payment_method_configuration: Optional[CreateInvoiceInputWithProductIDAndMemberIDPlanPaymentMethodConfiguration] + """The explicit payment method configuration for the plan. + + If not provided, the platform or company's defaults will apply. + """ + plan_type: Optional[PlanType] """The type of plan that can be attached to a product""" @@ -561,6 +677,34 @@ class CreateInvoiceInputWithProductIDAndEmailAddressPlanCustomField(TypedDict, t """Whether or not the field is required.""" +class CreateInvoiceInputWithProductIDAndEmailAddressPlanPaymentMethodConfiguration(TypedDict, total=False): + """The explicit payment method configuration for the plan. + + If not provided, the platform or company's defaults will apply. + """ + + disabled: Required[List[PaymentMethodTypes]] + """An array of payment method identifiers that are explicitly disabled. + + Only applies if the include_platform_defaults is true. + """ + + enabled: Required[List[PaymentMethodTypes]] + """An array of payment method identifiers that are explicitly enabled. + + This means these payment methods will be shown on checkout. Example use case is + to only enable a specific payment method like cashapp, or extending the platform + defaults with additional methods. + """ + + include_platform_defaults: Required[bool] + """ + Whether Whop's platform default payment method enablement settings are included + in this configuration. The full list of default payment methods can be found in + the documentation at docs.whop.com/payments. + """ + + class CreateInvoiceInputWithProductIDAndEmailAddressPlan(TypedDict, total=False): """ The plan attributes defining the price, currency, and billing interval for this invoice. @@ -592,6 +736,15 @@ class CreateInvoiceInputWithProductIDAndEmailAddressPlan(TypedDict, total=False) internal_notes: Optional[str] """A personal description or notes section for the business.""" + legacy_payment_method_controls: Optional[bool] + """Whether this plan uses legacy payment method controls""" + + payment_method_configuration: Optional[CreateInvoiceInputWithProductIDAndEmailAddressPlanPaymentMethodConfiguration] + """The explicit payment method configuration for the plan. + + If not provided, the platform or company's defaults will apply. + """ + plan_type: Optional[PlanType] """The type of plan that can be attached to a product""" diff --git a/src/whop_sdk/types/invoice_list_params.py b/src/whop_sdk/types/invoice_list_params.py index d1a4da26..2adb1912 100644 --- a/src/whop_sdk/types/invoice_list_params.py +++ b/src/whop_sdk/types/invoice_list_params.py @@ -4,7 +4,7 @@ from typing import List, Union, Optional from datetime import datetime -from typing_extensions import Literal, Required, Annotated, TypedDict +from typing_extensions import Literal, Annotated, TypedDict from .._types import SequenceNotStr from .._utils import PropertyInfo @@ -16,9 +16,6 @@ class InvoiceListParams(TypedDict, total=False): - company_id: Required[str] - """The unique identifier of the company to list invoices for.""" - after: Optional[str] """Returns the elements in the list that come after the specified cursor.""" @@ -28,6 +25,9 @@ class InvoiceListParams(TypedDict, total=False): collection_methods: Optional[List[CollectionMethod]] """Filter invoices by their collection method.""" + company_id: Optional[str] + """The unique identifier of the company to list invoices for.""" + created_after: Annotated[Union[str, datetime, None], PropertyInfo(format="iso8601")] """Only return invoices created after this timestamp.""" diff --git a/src/whop_sdk/types/membership_add_free_days_params.py b/src/whop_sdk/types/membership_add_free_days_params.py new file mode 100644 index 00000000..568b654b --- /dev/null +++ b/src/whop_sdk/types/membership_add_free_days_params.py @@ -0,0 +1,16 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from typing_extensions import Required, TypedDict + +__all__ = ["MembershipAddFreeDaysParams"] + + +class MembershipAddFreeDaysParams(TypedDict, total=False): + free_days: Required[int] + """The number of free days to add (1-1095). + + Extends the billing period, expiration date, or Stripe trial depending on plan + type. + """ diff --git a/src/whop_sdk/types/message_list_response.py b/src/whop_sdk/types/message_list_response.py index 92e9660e..f6652e99 100644 --- a/src/whop_sdk/types/message_list_response.py +++ b/src/whop_sdk/types/message_list_response.py @@ -87,6 +87,15 @@ class MessageListResponse(BaseModel): is_pinned: bool """Whether this message is pinned to the top of the channel for easy access.""" + mentions: List[str] + """A list of user IDs that are explicitly mentioned in this message.""" + + mentions_everyone: bool + """ + Whether the message includes an @everyone mention that notifies all channel + members. + """ + message_type: DmsPostTypes """The classification of this message: regular, system, or automated.""" diff --git a/src/whop_sdk/types/payment_list_response.py b/src/whop_sdk/types/payment_list_response.py index 438f5ecd..6ba171dd 100644 --- a/src/whop_sdk/types/payment_list_response.py +++ b/src/whop_sdk/types/payment_list_response.py @@ -9,6 +9,7 @@ from .shared.currency import Currency from .shared.promo_type import PromoType from .payment_method_types import PaymentMethodTypes +from .receipt_tax_behavior import ReceiptTaxBehavior from .shared.receipt_status import ReceiptStatus from .shared.membership_status import MembershipStatus from .shared.friendly_receipt_status import FriendlyReceiptStatus @@ -345,6 +346,15 @@ class PaymentListResponse(BaseModel): subtotal: Optional[float] = None """The subtotal to show to the creator (excluding buyer fees).""" + tax_amount: Optional[float] = None + """The calculated amount of the sales/VAT tax (if applicable).""" + + tax_behavior: Optional[ReceiptTaxBehavior] = None + """ + The type of tax inclusivity applied to the receipt, for determining whether the + tax is included in the final price, or paid on top. + """ + total: Optional[float] = None """The total to show to the creator (excluding buyer fees).""" diff --git a/src/whop_sdk/types/payment_method_types.py b/src/whop_sdk/types/payment_method_types.py index c61cc63f..1a74b27a 100644 --- a/src/whop_sdk/types/payment_method_types.py +++ b/src/whop_sdk/types/payment_method_types.py @@ -25,6 +25,7 @@ "cashapp", "claritypay", "coinbase", + "coinflow", "crypto", "custom", "customer_balance", diff --git a/src/whop_sdk/types/payment_provider.py b/src/whop_sdk/types/payment_provider.py index c2ba590b..748a6e2f 100644 --- a/src/whop_sdk/types/payment_provider.py +++ b/src/whop_sdk/types/payment_provider.py @@ -17,4 +17,5 @@ "claritypay", "checkout_dot_com", "airwallex", + "coinflow", ] diff --git a/src/whop_sdk/types/receipt_tax_behavior.py b/src/whop_sdk/types/receipt_tax_behavior.py new file mode 100644 index 00000000..3d0ea68a --- /dev/null +++ b/src/whop_sdk/types/receipt_tax_behavior.py @@ -0,0 +1,7 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing_extensions import Literal, TypeAlias + +__all__ = ["ReceiptTaxBehavior"] + +ReceiptTaxBehavior: TypeAlias = Literal["exclusive", "inclusive", "unspecified", "unable_to_collect"] diff --git a/src/whop_sdk/types/refund_created_webhook_event.py b/src/whop_sdk/types/refund_created_webhook_event.py index cd83e28c..3d2d9655 100644 --- a/src/whop_sdk/types/refund_created_webhook_event.py +++ b/src/whop_sdk/types/refund_created_webhook_event.py @@ -11,6 +11,7 @@ from .shared.currency import Currency from .payment_provider import PaymentProvider from .payment_method_types import PaymentMethodTypes +from .receipt_tax_behavior import ReceiptTaxBehavior from .refund_reference_type import RefundReferenceType from .refund_reference_status import RefundReferenceStatus from .shared.membership_status import MembershipStatus @@ -112,6 +113,18 @@ class DataPayment(BaseModel): subtotal: Optional[float] = None """The subtotal to show to the creator (excluding buyer fees).""" + tax_amount: Optional[float] = None + """The calculated amount of the sales/VAT tax (if applicable).""" + + tax_behavior: Optional[ReceiptTaxBehavior] = None + """ + The type of tax inclusivity applied to the receipt, for determining whether the + tax is included in the final price, or paid on top. + """ + + tax_refunded_amount: Optional[float] = None + """The amount of tax that has been refunded (if applicable).""" + total: Optional[float] = None """The total to show to the creator (excluding buyer fees).""" diff --git a/src/whop_sdk/types/refund_retrieve_response.py b/src/whop_sdk/types/refund_retrieve_response.py index 973ec6c3..57fc6384 100644 --- a/src/whop_sdk/types/refund_retrieve_response.py +++ b/src/whop_sdk/types/refund_retrieve_response.py @@ -10,6 +10,7 @@ from .shared.currency import Currency from .payment_provider import PaymentProvider from .payment_method_types import PaymentMethodTypes +from .receipt_tax_behavior import ReceiptTaxBehavior from .refund_reference_type import RefundReferenceType from .refund_reference_status import RefundReferenceStatus from .shared.membership_status import MembershipStatus @@ -104,6 +105,18 @@ class Payment(BaseModel): subtotal: Optional[float] = None """The subtotal to show to the creator (excluding buyer fees).""" + tax_amount: Optional[float] = None + """The calculated amount of the sales/VAT tax (if applicable).""" + + tax_behavior: Optional[ReceiptTaxBehavior] = None + """ + The type of tax inclusivity applied to the receipt, for determining whether the + tax is included in the final price, or paid on top. + """ + + tax_refunded_amount: Optional[float] = None + """The amount of tax that has been refunded (if applicable).""" + total: Optional[float] = None """The total to show to the creator (excluding buyer fees).""" diff --git a/src/whop_sdk/types/refund_updated_webhook_event.py b/src/whop_sdk/types/refund_updated_webhook_event.py index c7d7c86e..c5000b31 100644 --- a/src/whop_sdk/types/refund_updated_webhook_event.py +++ b/src/whop_sdk/types/refund_updated_webhook_event.py @@ -11,6 +11,7 @@ from .shared.currency import Currency from .payment_provider import PaymentProvider from .payment_method_types import PaymentMethodTypes +from .receipt_tax_behavior import ReceiptTaxBehavior from .refund_reference_type import RefundReferenceType from .refund_reference_status import RefundReferenceStatus from .shared.membership_status import MembershipStatus @@ -112,6 +113,18 @@ class DataPayment(BaseModel): subtotal: Optional[float] = None """The subtotal to show to the creator (excluding buyer fees).""" + tax_amount: Optional[float] = None + """The calculated amount of the sales/VAT tax (if applicable).""" + + tax_behavior: Optional[ReceiptTaxBehavior] = None + """ + The type of tax inclusivity applied to the receipt, for determining whether the + tax is included in the final price, or paid on top. + """ + + tax_refunded_amount: Optional[float] = None + """The amount of tax that has been refunded (if applicable).""" + total: Optional[float] = None """The total to show to the creator (excluding buyer fees).""" diff --git a/src/whop_sdk/types/shared/authorized_user_roles.py b/src/whop_sdk/types/shared/authorized_user_roles.py index 877db6d2..10d0fe2c 100644 --- a/src/whop_sdk/types/shared/authorized_user_roles.py +++ b/src/whop_sdk/types/shared/authorized_user_roles.py @@ -5,5 +5,5 @@ __all__ = ["AuthorizedUserRoles"] AuthorizedUserRoles: TypeAlias = Literal[ - "owner", "admin", "sales_manager", "moderator", "app_manager", "support", "manager" + "owner", "admin", "sales_manager", "moderator", "app_manager", "support", "manager", "custom" ] diff --git a/src/whop_sdk/types/shared/company.py b/src/whop_sdk/types/shared/company.py index e30b8c1d..6f4bf53e 100644 --- a/src/whop_sdk/types/shared/company.py +++ b/src/whop_sdk/types/shared/company.py @@ -2,9 +2,9 @@ from typing import Dict, List, Optional from datetime import datetime -from typing_extensions import Literal from ..._models import BaseModel +from ..social_link_websites import SocialLinkWebsites __all__ = ["Company", "Logo", "OwnerUser", "SocialLink"] @@ -41,7 +41,7 @@ class SocialLink(BaseModel): url: str """The URL of the social media profile or external link.""" - website: Literal["x", "instagram", "facebook", "tiktok", "youtube", "linkedin", "twitch", "website", "custom"] + website: SocialLinkWebsites """The website""" diff --git a/src/whop_sdk/types/shared/forum_post.py b/src/whop_sdk/types/shared/forum_post.py index d3af3981..7a6136d7 100644 --- a/src/whop_sdk/types/shared/forum_post.py +++ b/src/whop_sdk/types/shared/forum_post.py @@ -1,11 +1,37 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. -from typing import Optional +from typing import List, Optional from datetime import datetime from ..._models import BaseModel -__all__ = ["ForumPost", "User"] +__all__ = ["ForumPost", "Attachment", "User"] + + +class Attachment(BaseModel): + """Represents an image attachment""" + + id: str + """Represents a unique identifier that is Base64 obfuscated. + + It is often used to refetch an object or as key for a cache. The ID type appears + in a JSON response as a String; however, it is not intended to be + human-readable. When expected as an input type, any string (such as + `"VXNlci0xMA=="`) or integer (such as `4`) input value will be accepted as an + ID. + """ + + content_type: Optional[str] = None + """The MIME type of the uploaded file (e.g., image/jpeg, video/mp4, audio/mpeg).""" + + filename: Optional[str] = None + """The original filename of the uploaded attachment, including its file extension.""" + + url: Optional[str] = None + """A pre-optimized URL for rendering this attachment on the client. + + This should be used for displaying attachments in apps. + """ class User(BaseModel): @@ -36,6 +62,9 @@ class ForumPost(BaseModel): ID. """ + attachments: List[Attachment] + """All file attachments on this post, such as images, documents, and videos.""" + comment_count: int """The total number of direct comments on this post.""" diff --git a/src/whop_sdk/types/shared/message.py b/src/whop_sdk/types/shared/message.py index 5b0ad97d..a24f502d 100644 --- a/src/whop_sdk/types/shared/message.py +++ b/src/whop_sdk/types/shared/message.py @@ -87,6 +87,15 @@ class Message(BaseModel): is_pinned: bool """Whether this message is pinned to the top of the channel for easy access.""" + mentions: List[str] + """A list of user IDs that are explicitly mentioned in this message.""" + + mentions_everyone: bool + """ + Whether the message includes an @everyone mention that notifies all channel + members. + """ + message_type: DmsPostTypes """The classification of this message: regular, system, or automated.""" diff --git a/src/whop_sdk/types/shared/payment.py b/src/whop_sdk/types/shared/payment.py index 07f5c8d5..6993b54d 100644 --- a/src/whop_sdk/types/shared/payment.py +++ b/src/whop_sdk/types/shared/payment.py @@ -13,6 +13,7 @@ from ..dispute_statuses import DisputeStatuses from .membership_status import MembershipStatus from ..payment_method_types import PaymentMethodTypes +from ..receipt_tax_behavior import ReceiptTaxBehavior from .friendly_receipt_status import FriendlyReceiptStatus __all__ = [ @@ -509,6 +510,18 @@ class Payment(BaseModel): subtotal: Optional[float] = None """The subtotal to show to the creator (excluding buyer fees).""" + tax_amount: Optional[float] = None + """The calculated amount of the sales/VAT tax (if applicable).""" + + tax_behavior: Optional[ReceiptTaxBehavior] = None + """ + The type of tax inclusivity applied to the receipt, for determining whether the + tax is included in the final price, or paid on top. + """ + + tax_refunded_amount: Optional[float] = None + """The amount of tax that has been refunded (if applicable).""" + total: Optional[float] = None """The total to show to the creator (excluding buyer fees).""" diff --git a/src/whop_sdk/types/shared_params/authorized_user_roles.py b/src/whop_sdk/types/shared_params/authorized_user_roles.py index 2235fde7..c61f3cc6 100644 --- a/src/whop_sdk/types/shared_params/authorized_user_roles.py +++ b/src/whop_sdk/types/shared_params/authorized_user_roles.py @@ -7,5 +7,5 @@ __all__ = ["AuthorizedUserRoles"] AuthorizedUserRoles: TypeAlias = Literal[ - "owner", "admin", "sales_manager", "moderator", "app_manager", "support", "manager" + "owner", "admin", "sales_manager", "moderator", "app_manager", "support", "manager", "custom" ] diff --git a/src/whop_sdk/types/social_link_websites.py b/src/whop_sdk/types/social_link_websites.py new file mode 100644 index 00000000..7e96a15d --- /dev/null +++ b/src/whop_sdk/types/social_link_websites.py @@ -0,0 +1,9 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from typing_extensions import Literal, TypeAlias + +__all__ = ["SocialLinkWebsites"] + +SocialLinkWebsites: TypeAlias = Literal[ + "x", "instagram", "facebook", "tiktok", "youtube", "linkedin", "twitch", "website", "custom" +] diff --git a/tests/api_resources/test_ai_chats.py b/tests/api_resources/test_ai_chats.py index 8681f573..3f155d29 100644 --- a/tests/api_resources/test_ai_chats.py +++ b/tests/api_resources/test_ai_chats.py @@ -38,6 +38,7 @@ def test_method_create_with_all_params(self, client: Whop) -> None: current_company_id="current_company_id", message_attachments=[{"id": "id"}], message_source="manual", + suggestion_type="suggestion_type", title="title", ) assert_matches_type(AIChat, ai_chat, path=["response"]) @@ -265,6 +266,7 @@ async def test_method_create_with_all_params(self, async_client: AsyncWhop) -> N current_company_id="current_company_id", message_attachments=[{"id": "id"}], message_source="manual", + suggestion_type="suggestion_type", title="title", ) assert_matches_type(AIChat, ai_chat, path=["response"]) diff --git a/tests/api_resources/test_authorized_users.py b/tests/api_resources/test_authorized_users.py index a0e6a63f..945730cd 100644 --- a/tests/api_resources/test_authorized_users.py +++ b/tests/api_resources/test_authorized_users.py @@ -11,6 +11,8 @@ from tests.utils import assert_matches_type from whop_sdk.types import ( AuthorizedUserListResponse, + AuthorizedUserCreateResponse, + AuthorizedUserDeleteResponse, AuthorizedUserRetrieveResponse, ) from whop_sdk._utils import parse_datetime @@ -22,6 +24,57 @@ class TestAuthorizedUsers: parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_method_create(self, client: Whop) -> None: + authorized_user = client.authorized_users.create( + company_id="biz_xxxxxxxxxxxxxx", + role="owner", + user_id="user_xxxxxxxxxxxxx", + ) + assert_matches_type(AuthorizedUserCreateResponse, authorized_user, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_method_create_with_all_params(self, client: Whop) -> None: + authorized_user = client.authorized_users.create( + company_id="biz_xxxxxxxxxxxxxx", + role="owner", + user_id="user_xxxxxxxxxxxxx", + send_emails=True, + ) + assert_matches_type(AuthorizedUserCreateResponse, authorized_user, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_raw_response_create(self, client: Whop) -> None: + response = client.authorized_users.with_raw_response.create( + company_id="biz_xxxxxxxxxxxxxx", + role="owner", + user_id="user_xxxxxxxxxxxxx", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + authorized_user = response.parse() + assert_matches_type(AuthorizedUserCreateResponse, authorized_user, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_streaming_response_create(self, client: Whop) -> None: + with client.authorized_users.with_streaming_response.create( + company_id="biz_xxxxxxxxxxxxxx", + role="owner", + user_id="user_xxxxxxxxxxxxx", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + authorized_user = response.parse() + assert_matches_type(AuthorizedUserCreateResponse, authorized_user, path=["response"]) + + assert cast(Any, response.is_closed) is True + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_retrieve(self, client: Whop) -> None: @@ -108,12 +161,114 @@ def test_streaming_response_list(self, client: Whop) -> None: assert cast(Any, response.is_closed) is True + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_method_delete(self, client: Whop) -> None: + authorized_user = client.authorized_users.delete( + id="ausr_xxxxxxxxxxxxx", + ) + assert_matches_type(AuthorizedUserDeleteResponse, authorized_user, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_method_delete_with_all_params(self, client: Whop) -> None: + authorized_user = client.authorized_users.delete( + id="ausr_xxxxxxxxxxxxx", + company_id="biz_xxxxxxxxxxxxxx", + ) + assert_matches_type(AuthorizedUserDeleteResponse, authorized_user, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_raw_response_delete(self, client: Whop) -> None: + response = client.authorized_users.with_raw_response.delete( + id="ausr_xxxxxxxxxxxxx", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + authorized_user = response.parse() + assert_matches_type(AuthorizedUserDeleteResponse, authorized_user, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_streaming_response_delete(self, client: Whop) -> None: + with client.authorized_users.with_streaming_response.delete( + id="ausr_xxxxxxxxxxxxx", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + authorized_user = response.parse() + assert_matches_type(AuthorizedUserDeleteResponse, authorized_user, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_path_params_delete(self, client: Whop) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): + client.authorized_users.with_raw_response.delete( + id="", + ) + class TestAsyncAuthorizedUsers: parametrize = pytest.mark.parametrize( "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] ) + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_method_create(self, async_client: AsyncWhop) -> None: + authorized_user = await async_client.authorized_users.create( + company_id="biz_xxxxxxxxxxxxxx", + role="owner", + user_id="user_xxxxxxxxxxxxx", + ) + assert_matches_type(AuthorizedUserCreateResponse, authorized_user, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_method_create_with_all_params(self, async_client: AsyncWhop) -> None: + authorized_user = await async_client.authorized_users.create( + company_id="biz_xxxxxxxxxxxxxx", + role="owner", + user_id="user_xxxxxxxxxxxxx", + send_emails=True, + ) + assert_matches_type(AuthorizedUserCreateResponse, authorized_user, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_raw_response_create(self, async_client: AsyncWhop) -> None: + response = await async_client.authorized_users.with_raw_response.create( + company_id="biz_xxxxxxxxxxxxxx", + role="owner", + user_id="user_xxxxxxxxxxxxx", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + authorized_user = await response.parse() + assert_matches_type(AuthorizedUserCreateResponse, authorized_user, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_streaming_response_create(self, async_client: AsyncWhop) -> None: + async with async_client.authorized_users.with_streaming_response.create( + company_id="biz_xxxxxxxxxxxxxx", + role="owner", + user_id="user_xxxxxxxxxxxxx", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + authorized_user = await response.parse() + assert_matches_type(AuthorizedUserCreateResponse, authorized_user, path=["response"]) + + assert cast(Any, response.is_closed) is True + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_retrieve(self, async_client: AsyncWhop) -> None: @@ -199,3 +354,54 @@ async def test_streaming_response_list(self, async_client: AsyncWhop) -> None: assert_matches_type(AsyncCursorPage[AuthorizedUserListResponse], authorized_user, path=["response"]) assert cast(Any, response.is_closed) is True + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_method_delete(self, async_client: AsyncWhop) -> None: + authorized_user = await async_client.authorized_users.delete( + id="ausr_xxxxxxxxxxxxx", + ) + assert_matches_type(AuthorizedUserDeleteResponse, authorized_user, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_method_delete_with_all_params(self, async_client: AsyncWhop) -> None: + authorized_user = await async_client.authorized_users.delete( + id="ausr_xxxxxxxxxxxxx", + company_id="biz_xxxxxxxxxxxxxx", + ) + assert_matches_type(AuthorizedUserDeleteResponse, authorized_user, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_raw_response_delete(self, async_client: AsyncWhop) -> None: + response = await async_client.authorized_users.with_raw_response.delete( + id="ausr_xxxxxxxxxxxxx", + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + authorized_user = await response.parse() + assert_matches_type(AuthorizedUserDeleteResponse, authorized_user, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_streaming_response_delete(self, async_client: AsyncWhop) -> None: + async with async_client.authorized_users.with_streaming_response.delete( + id="ausr_xxxxxxxxxxxxx", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + authorized_user = await response.parse() + assert_matches_type(AuthorizedUserDeleteResponse, authorized_user, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_path_params_delete(self, async_client: AsyncWhop) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): + await async_client.authorized_users.with_raw_response.delete( + id="", + ) diff --git a/tests/api_resources/test_companies.py b/tests/api_resources/test_companies.py index 30eb5ebd..707ad468 100644 --- a/tests/api_resources/test_companies.py +++ b/tests/api_resources/test_companies.py @@ -130,6 +130,16 @@ def test_method_update_with_all_params(self, client: Whop) -> None: logo={"id": "id"}, route="route", send_customer_emails=True, + social_links=[ + { + "url": "https://example.com/path", + "website": "x", + "image": {"id": "id"}, + "order": "123.45", + "title": "title", + "website_order": "123.45", + } + ], target_audience="target_audience", title="title", ) @@ -326,6 +336,16 @@ async def test_method_update_with_all_params(self, async_client: AsyncWhop) -> N logo={"id": "id"}, route="route", send_customer_emails=True, + social_links=[ + { + "url": "https://example.com/path", + "website": "x", + "image": {"id": "id"}, + "order": "123.45", + "title": "title", + "website_order": "123.45", + } + ], target_audience="target_audience", title="title", ) diff --git a/tests/api_resources/test_forum_posts.py b/tests/api_resources/test_forum_posts.py index ead26f5a..c02f5b99 100644 --- a/tests/api_resources/test_forum_posts.py +++ b/tests/api_resources/test_forum_posts.py @@ -50,6 +50,7 @@ def test_method_create_with_all_params(self, client: Whop) -> None: } ] }, + rich_content="rich_content", title="title", visibility="members_only", ) @@ -261,6 +262,7 @@ async def test_method_create_with_all_params(self, async_client: AsyncWhop) -> N } ] }, + rich_content="rich_content", title="title", visibility="members_only", ) diff --git a/tests/api_resources/test_forums.py b/tests/api_resources/test_forums.py index eef1173c..1b1fdfea 100644 --- a/tests/api_resources/test_forums.py +++ b/tests/api_resources/test_forums.py @@ -74,6 +74,7 @@ def test_method_update(self, client: Whop) -> None: def test_method_update_with_all_params(self, client: Whop) -> None: forum = client.forums.update( id="id", + banner_image={"id": "id"}, email_notification_preference="all_admin_posts", who_can_comment="everyone", who_can_post="everyone", @@ -222,6 +223,7 @@ async def test_method_update(self, async_client: AsyncWhop) -> None: async def test_method_update_with_all_params(self, async_client: AsyncWhop) -> None: forum = await async_client.forums.update( id="id", + banner_image={"id": "id"}, email_notification_preference="all_admin_posts", who_can_comment="everyone", who_can_post="everyone", diff --git a/tests/api_resources/test_invoices.py b/tests/api_resources/test_invoices.py index 7db7c125..8ff6287c 100644 --- a/tests/api_resources/test_invoices.py +++ b/tests/api_resources/test_invoices.py @@ -57,6 +57,12 @@ def test_method_create_with_all_params_overload_1(self, client: Whop) -> None: "expiration_days": 42, "initial_price": 6.9, "internal_notes": "internal_notes", + "legacy_payment_method_controls": True, + "payment_method_configuration": { + "disabled": ["acss_debit"], + "enabled": ["acss_debit"], + "include_platform_defaults": True, + }, "plan_type": "renewal", "release_method": "buy_now", "renewal_price": 6.9, @@ -150,6 +156,12 @@ def test_method_create_with_all_params_overload_2(self, client: Whop) -> None: "expiration_days": 42, "initial_price": 6.9, "internal_notes": "internal_notes", + "legacy_payment_method_controls": True, + "payment_method_configuration": { + "disabled": ["acss_debit"], + "enabled": ["acss_debit"], + "include_platform_defaults": True, + }, "plan_type": "renewal", "release_method": "buy_now", "renewal_price": 6.9, @@ -243,6 +255,12 @@ def test_method_create_with_all_params_overload_3(self, client: Whop) -> None: "expiration_days": 42, "initial_price": 6.9, "internal_notes": "internal_notes", + "legacy_payment_method_controls": True, + "payment_method_configuration": { + "disabled": ["acss_debit"], + "enabled": ["acss_debit"], + "include_platform_defaults": True, + }, "plan_type": "renewal", "release_method": "buy_now", "renewal_price": 6.9, @@ -333,6 +351,12 @@ def test_method_create_with_all_params_overload_4(self, client: Whop) -> None: "expiration_days": 42, "initial_price": 6.9, "internal_notes": "internal_notes", + "legacy_payment_method_controls": True, + "payment_method_configuration": { + "disabled": ["acss_debit"], + "enabled": ["acss_debit"], + "include_platform_defaults": True, + }, "plan_type": "renewal", "release_method": "buy_now", "renewal_price": 6.9, @@ -431,19 +455,17 @@ def test_path_params_retrieve(self, client: Whop) -> None: @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_list(self, client: Whop) -> None: - invoice = client.invoices.list( - company_id="biz_xxxxxxxxxxxxxx", - ) + invoice = client.invoices.list() assert_matches_type(SyncCursorPage[InvoiceListItem], invoice, path=["response"]) @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_list_with_all_params(self, client: Whop) -> None: invoice = client.invoices.list( - company_id="biz_xxxxxxxxxxxxxx", after="after", before="before", collection_methods=["send_invoice"], + company_id="biz_xxxxxxxxxxxxxx", created_after=parse_datetime("2023-12-01T05:00:00.401Z"), created_before=parse_datetime("2023-12-01T05:00:00.401Z"), direction="asc", @@ -458,9 +480,7 @@ def test_method_list_with_all_params(self, client: Whop) -> None: @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_list(self, client: Whop) -> None: - response = client.invoices.with_raw_response.list( - company_id="biz_xxxxxxxxxxxxxx", - ) + response = client.invoices.with_raw_response.list() assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" @@ -470,9 +490,7 @@ def test_raw_response_list(self, client: Whop) -> None: @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_list(self, client: Whop) -> None: - with client.invoices.with_streaming_response.list( - company_id="biz_xxxxxxxxxxxxxx", - ) as response: + with client.invoices.with_streaming_response.list() as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" @@ -566,6 +584,12 @@ async def test_method_create_with_all_params_overload_1(self, async_client: Asyn "expiration_days": 42, "initial_price": 6.9, "internal_notes": "internal_notes", + "legacy_payment_method_controls": True, + "payment_method_configuration": { + "disabled": ["acss_debit"], + "enabled": ["acss_debit"], + "include_platform_defaults": True, + }, "plan_type": "renewal", "release_method": "buy_now", "renewal_price": 6.9, @@ -659,6 +683,12 @@ async def test_method_create_with_all_params_overload_2(self, async_client: Asyn "expiration_days": 42, "initial_price": 6.9, "internal_notes": "internal_notes", + "legacy_payment_method_controls": True, + "payment_method_configuration": { + "disabled": ["acss_debit"], + "enabled": ["acss_debit"], + "include_platform_defaults": True, + }, "plan_type": "renewal", "release_method": "buy_now", "renewal_price": 6.9, @@ -752,6 +782,12 @@ async def test_method_create_with_all_params_overload_3(self, async_client: Asyn "expiration_days": 42, "initial_price": 6.9, "internal_notes": "internal_notes", + "legacy_payment_method_controls": True, + "payment_method_configuration": { + "disabled": ["acss_debit"], + "enabled": ["acss_debit"], + "include_platform_defaults": True, + }, "plan_type": "renewal", "release_method": "buy_now", "renewal_price": 6.9, @@ -842,6 +878,12 @@ async def test_method_create_with_all_params_overload_4(self, async_client: Asyn "expiration_days": 42, "initial_price": 6.9, "internal_notes": "internal_notes", + "legacy_payment_method_controls": True, + "payment_method_configuration": { + "disabled": ["acss_debit"], + "enabled": ["acss_debit"], + "include_platform_defaults": True, + }, "plan_type": "renewal", "release_method": "buy_now", "renewal_price": 6.9, @@ -940,19 +982,17 @@ async def test_path_params_retrieve(self, async_client: AsyncWhop) -> None: @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_list(self, async_client: AsyncWhop) -> None: - invoice = await async_client.invoices.list( - company_id="biz_xxxxxxxxxxxxxx", - ) + invoice = await async_client.invoices.list() assert_matches_type(AsyncCursorPage[InvoiceListItem], invoice, path=["response"]) @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_list_with_all_params(self, async_client: AsyncWhop) -> None: invoice = await async_client.invoices.list( - company_id="biz_xxxxxxxxxxxxxx", after="after", before="before", collection_methods=["send_invoice"], + company_id="biz_xxxxxxxxxxxxxx", created_after=parse_datetime("2023-12-01T05:00:00.401Z"), created_before=parse_datetime("2023-12-01T05:00:00.401Z"), direction="asc", @@ -967,9 +1007,7 @@ async def test_method_list_with_all_params(self, async_client: AsyncWhop) -> Non @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_list(self, async_client: AsyncWhop) -> None: - response = await async_client.invoices.with_raw_response.list( - company_id="biz_xxxxxxxxxxxxxx", - ) + response = await async_client.invoices.with_raw_response.list() assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" @@ -979,9 +1017,7 @@ async def test_raw_response_list(self, async_client: AsyncWhop) -> None: @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_list(self, async_client: AsyncWhop) -> None: - async with async_client.invoices.with_streaming_response.list( - company_id="biz_xxxxxxxxxxxxxx", - ) as response: + async with async_client.invoices.with_streaming_response.list() as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" diff --git a/tests/api_resources/test_memberships.py b/tests/api_resources/test_memberships.py index 2972632c..69df8fcd 100644 --- a/tests/api_resources/test_memberships.py +++ b/tests/api_resources/test_memberships.py @@ -165,6 +165,52 @@ def test_streaming_response_list(self, client: Whop) -> None: assert cast(Any, response.is_closed) is True + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_method_add_free_days(self, client: Whop) -> None: + membership = client.memberships.add_free_days( + id="mem_xxxxxxxxxxxxxx", + free_days=42, + ) + assert_matches_type(Membership, membership, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_raw_response_add_free_days(self, client: Whop) -> None: + response = client.memberships.with_raw_response.add_free_days( + id="mem_xxxxxxxxxxxxxx", + free_days=42, + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + membership = response.parse() + assert_matches_type(Membership, membership, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_streaming_response_add_free_days(self, client: Whop) -> None: + with client.memberships.with_streaming_response.add_free_days( + id="mem_xxxxxxxxxxxxxx", + free_days=42, + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + membership = response.parse() + assert_matches_type(Membership, membership, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + def test_path_params_add_free_days(self, client: Whop) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): + client.memberships.with_raw_response.add_free_days( + id="", + free_days=42, + ) + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_cancel(self, client: Whop) -> None: @@ -500,6 +546,52 @@ async def test_streaming_response_list(self, async_client: AsyncWhop) -> None: assert cast(Any, response.is_closed) is True + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_method_add_free_days(self, async_client: AsyncWhop) -> None: + membership = await async_client.memberships.add_free_days( + id="mem_xxxxxxxxxxxxxx", + free_days=42, + ) + assert_matches_type(Membership, membership, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_raw_response_add_free_days(self, async_client: AsyncWhop) -> None: + response = await async_client.memberships.with_raw_response.add_free_days( + id="mem_xxxxxxxxxxxxxx", + free_days=42, + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + membership = await response.parse() + assert_matches_type(Membership, membership, path=["response"]) + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_streaming_response_add_free_days(self, async_client: AsyncWhop) -> None: + async with async_client.memberships.with_streaming_response.add_free_days( + id="mem_xxxxxxxxxxxxxx", + free_days=42, + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + membership = await response.parse() + assert_matches_type(Membership, membership, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @pytest.mark.skip(reason="Mock server tests are disabled") + @parametrize + async def test_path_params_add_free_days(self, async_client: AsyncWhop) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): + await async_client.memberships.with_raw_response.add_free_days( + id="", + free_days=42, + ) + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_cancel(self, async_client: AsyncWhop) -> None: diff --git a/tests/api_resources/test_webhooks.py b/tests/api_resources/test_webhooks.py index be74c103..fb41f430 100644 --- a/tests/api_resources/test_webhooks.py +++ b/tests/api_resources/test_webhooks.py @@ -257,9 +257,20 @@ def test_path_params_delete(self, client: Whop) -> None: "", ) - def test_method_unwrap(self, client: Whop) -> None: - key = b"secret" - hook = standardwebhooks.Webhook(key) + @pytest.mark.parametrize( + "client_opt,method_opt", + [ + ("whsec_c2VjcmV0Cg==", None), + ("wrong", b"secret\n"), + ("wrong", "whsec_c2VjcmV0Cg=="), + (None, b"secret\n"), + (None, "whsec_c2VjcmV0Cg=="), + ], + ) + def test_method_unwrap(self, client: Whop, client_opt: str | None, method_opt: str | bytes | None) -> None: + hook = standardwebhooks.Webhook(b"secret\n") + + client = client.with_options(webhook_key=client_opt) data = """{"id":"msg_xxxxxxxxxxxxxxxxxxxxxxxx","api_version":"v1","data":{"id":"inv_xxxxxxxxxxxxxx","created_at":"2023-12-01T05:00:00.401Z","current_plan":{"id":"plan_xxxxxxxxxxxxx","currency":"usd","formatted_price":"$10.00"},"due_date":"2023-12-01T05:00:00.401Z","email_address":"customer@example.com","fetch_invoice_token":"eyJhbGciOiJIUzI1NiJ9...","number":"#0001","status":"draft","user":{"id":"user_xxxxxxxxxxxxx","name":"John Doe","username":"johndoe42"}},"timestamp":"2025-01-01T00:00:00.000Z","type":"invoice.created","company_id":"biz_xxxxxxxxxxxxxx"}""" msg_id = "1" @@ -272,7 +283,7 @@ def test_method_unwrap(self, client: Whop) -> None: } try: - _ = client.webhooks.unwrap(data, headers=headers, key=key) + _ = client.webhooks.unwrap(data, headers=headers, key=method_opt) except standardwebhooks.WebhookVerificationError as e: raise AssertionError("Failed to unwrap valid webhook") from e @@ -283,7 +294,7 @@ def test_method_unwrap(self, client: Whop) -> None: ] for bad_header in bad_headers: with pytest.raises(standardwebhooks.WebhookVerificationError): - _ = client.webhooks.unwrap(data, headers=bad_header, key=key) + _ = client.webhooks.unwrap(data, headers=bad_header, key=method_opt) class TestAsyncWebhooks: @@ -523,9 +534,20 @@ async def test_path_params_delete(self, async_client: AsyncWhop) -> None: "", ) - def test_method_unwrap(self, client: Whop) -> None: - key = b"secret" - hook = standardwebhooks.Webhook(key) + @pytest.mark.parametrize( + "client_opt,method_opt", + [ + ("whsec_c2VjcmV0Cg==", None), + ("wrong", b"secret\n"), + ("wrong", "whsec_c2VjcmV0Cg=="), + (None, b"secret\n"), + (None, "whsec_c2VjcmV0Cg=="), + ], + ) + def test_method_unwrap(self, async_client: Whop, client_opt: str | None, method_opt: str | bytes | None) -> None: + hook = standardwebhooks.Webhook(b"secret\n") + + async_client = async_client.with_options(webhook_key=client_opt) data = """{"id":"msg_xxxxxxxxxxxxxxxxxxxxxxxx","api_version":"v1","data":{"id":"inv_xxxxxxxxxxxxxx","created_at":"2023-12-01T05:00:00.401Z","current_plan":{"id":"plan_xxxxxxxxxxxxx","currency":"usd","formatted_price":"$10.00"},"due_date":"2023-12-01T05:00:00.401Z","email_address":"customer@example.com","fetch_invoice_token":"eyJhbGciOiJIUzI1NiJ9...","number":"#0001","status":"draft","user":{"id":"user_xxxxxxxxxxxxx","name":"John Doe","username":"johndoe42"}},"timestamp":"2025-01-01T00:00:00.000Z","type":"invoice.created","company_id":"biz_xxxxxxxxxxxxxx"}""" msg_id = "1" @@ -538,7 +560,7 @@ def test_method_unwrap(self, client: Whop) -> None: } try: - _ = client.webhooks.unwrap(data, headers=headers, key=key) + _ = async_client.webhooks.unwrap(data, headers=headers, key=method_opt) except standardwebhooks.WebhookVerificationError as e: raise AssertionError("Failed to unwrap valid webhook") from e @@ -549,4 +571,4 @@ def test_method_unwrap(self, client: Whop) -> None: ] for bad_header in bad_headers: with pytest.raises(standardwebhooks.WebhookVerificationError): - _ = client.webhooks.unwrap(data, headers=bad_header, key=key) + _ = async_client.webhooks.unwrap(data, headers=bad_header, key=method_opt)