diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index f93be0ea..eefc48ef 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -61,18 +61,14 @@ jobs: run: rye build - name: Get GitHub OIDC Token - if: |- - github.repository == 'stainless-sdks/whopsdk-python' && - !startsWith(github.ref, 'refs/heads/stl/') + if: github.repository == 'stainless-sdks/whopsdk-python' 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' && - !startsWith(github.ref, 'refs/heads/stl/') + if: github.repository == 'stainless-sdks/whopsdk-python' 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 3d2ac0bd..34ac707c 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.1.0" + ".": "0.0.30" } \ No newline at end of file diff --git a/.stats.yml b/.stats.yml index cbc67135..f91f6ee2 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ -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 +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 diff --git a/CHANGELOG.md b/CHANGELOG.md index eb73b72b..dd2e1246 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,32 +1,5 @@ # 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 cb3e0091..679a9af1 100644 --- a/api.md +++ b/api.md @@ -121,7 +121,7 @@ Methods: Types: ```python -from whop_sdk.types import SocialLinkWebsites, CompanyListResponse +from whop_sdk.types import CompanyListResponse ``` Methods: @@ -268,7 +268,6 @@ 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 @@ -279,20 +278,13 @@ Methods: Types: ```python -from whop_sdk.types import ( - AuthorizedUserCreateResponse, - AuthorizedUserRetrieveResponse, - AuthorizedUserListResponse, - AuthorizedUserDeleteResponse, -) +from whop_sdk.types import AuthorizedUserRetrieveResponse, AuthorizedUserListResponse ``` 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 @@ -390,7 +382,6 @@ from whop_sdk.types import ( BillingReasons, CardBrands, PaymentMethodTypes, - ReceiptTaxBehavior, PaymentListResponse, PaymentListFeesResponse, ) diff --git a/pyproject.toml b/pyproject.toml index 9279b720..80fe5263 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "whop-sdk" -version = "0.1.0" +version = "0.0.30" 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 ae5d5c9f..65a4f492 100644 --- a/src/whop_sdk/_client.py +++ b/src/whop_sdk/_client.py @@ -215,350 +215,300 @@ 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) @@ -753,350 +703,300 @@ 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) @@ -1227,350 +1127,300 @@ 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) @@ -1584,14 +1434,12 @@ 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) @@ -1600,301 +1448,258 @@ 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) @@ -1903,35 +1708,30 @@ 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) @@ -1945,14 +1745,12 @@ 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) @@ -1961,301 +1759,258 @@ 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) @@ -2264,35 +2019,30 @@ 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) @@ -2306,14 +2056,12 @@ 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) @@ -2322,91 +2070,78 @@ 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) @@ -2415,210 +2150,180 @@ 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) @@ -2627,35 +2332,30 @@ 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 162053b4..c674ff57 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.1.0" # x-release-please-version +__version__ = "0.0.30" # x-release-please-version diff --git a/src/whop_sdk/resources/access_tokens.py b/src/whop_sdk/resources/access_tokens.py index 1ebde168..ec9b7832 100644 --- a/src/whop_sdk/resources/access_tokens.py +++ b/src/whop_sdk/resources/access_tokens.py @@ -25,8 +25,6 @@ class AccessTokensResource(SyncAPIResource): - """Access tokens""" - @cached_property def with_raw_response(self) -> AccessTokensResourceWithRawResponse: """ @@ -108,8 +106,6 @@ 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 ccfe5cd7..e362e3fb 100644 --- a/src/whop_sdk/resources/account_links.py +++ b/src/whop_sdk/resources/account_links.py @@ -24,8 +24,6 @@ class AccountLinksResource(SyncAPIResource): - """Account links""" - @cached_property def with_raw_response(self) -> AccountLinksResourceWithRawResponse: """ @@ -103,8 +101,6 @@ 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 cd1fe56a..cd24246c 100644 --- a/src/whop_sdk/resources/ai_chats.py +++ b/src/whop_sdk/resources/ai_chats.py @@ -28,8 +28,6 @@ class AIChatsResource(SyncAPIResource): - """Ai chats""" - @cached_property def with_raw_response(self) -> AIChatsResourceWithRawResponse: """ @@ -56,7 +54,6 @@ 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. @@ -83,9 +80,6 @@ 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 @@ -104,7 +98,6 @@ 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, @@ -293,8 +286,6 @@ def delete( class AsyncAIChatsResource(AsyncAPIResource): - """Ai chats""" - @cached_property def with_raw_response(self) -> AsyncAIChatsResourceWithRawResponse: """ @@ -321,7 +312,6 @@ 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. @@ -348,9 +338,6 @@ 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 @@ -369,7 +356,6 @@ 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 967b89fd..e4e0f855 100644 --- a/src/whop_sdk/resources/app_builds.py +++ b/src/whop_sdk/resources/app_builds.py @@ -30,8 +30,6 @@ class AppBuildsResource(SyncAPIResource): - """App builds""" - @cached_property def with_raw_response(self) -> AppBuildsResourceWithRawResponse: """ @@ -278,8 +276,6 @@ 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 dd29aa84..46fd9b78 100644 --- a/src/whop_sdk/resources/apps.py +++ b/src/whop_sdk/resources/apps.py @@ -31,8 +31,6 @@ class AppsResource(SyncAPIResource): - """Apps""" - @cached_property def with_raw_response(self) -> AppsResourceWithRawResponse: """ @@ -356,8 +354,6 @@ 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 b1f3fd19..91158b83 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, authorized_user_create_params, authorized_user_delete_params +from ..types import authorized_user_list_params from .._types import Body, Omit, Query, Headers, NotGiven, omit, not_given -from .._utils import maybe_transform, async_maybe_transform +from .._utils import maybe_transform from .._compat import cached_property from .._resource import SyncAPIResource, AsyncAPIResource from .._response import ( @@ -22,16 +22,12 @@ 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: """ @@ -51,64 +47,6 @@ 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, @@ -229,57 +167,8 @@ 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: """ @@ -299,64 +188,6 @@ 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, @@ -477,121 +308,50 @@ 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 04382738..0ed7bd7f 100644 --- a/src/whop_sdk/resources/chat_channels.py +++ b/src/whop_sdk/resources/chat_channels.py @@ -28,8 +28,6 @@ class ChatChannelsResource(SyncAPIResource): - """Chat channels""" - @cached_property def with_raw_response(self) -> ChatChannelsResourceWithRawResponse: """ @@ -226,8 +224,6 @@ 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 8df82b2c..01606287 100644 --- a/src/whop_sdk/resources/checkout_configurations.py +++ b/src/whop_sdk/resources/checkout_configurations.py @@ -30,8 +30,6 @@ class CheckoutConfigurationsResource(SyncAPIResource): - """Checkout configurations""" - @cached_property def with_raw_response(self) -> CheckoutConfigurationsResourceWithRawResponse: """ @@ -398,8 +396,6 @@ 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 ae00db09..37cb0775 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, Iterable, Optional +from typing import Dict, Union, Optional from datetime import datetime import httpx @@ -28,8 +28,6 @@ class CompaniesResource(SyncAPIResource): - """Companies""" - @cached_property def with_raw_response(self) -> CompaniesResourceWithRawResponse: """ @@ -170,7 +168,6 @@ 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. @@ -203,9 +200,6 @@ 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'). @@ -230,7 +224,6 @@ def update( "logo": logo, "route": route, "send_customer_emails": send_customer_emails, - "social_links": social_links, "target_audience": target_audience, "title": title, }, @@ -324,8 +317,6 @@ def list( class AsyncCompaniesResource(AsyncAPIResource): - """Companies""" - @cached_property def with_raw_response(self) -> AsyncCompaniesResourceWithRawResponse: """ @@ -466,7 +457,6 @@ 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. @@ -499,9 +489,6 @@ 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'). @@ -526,7 +513,6 @@ 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 ff382499..aa7bf6ce 100644 --- a/src/whop_sdk/resources/company_token_transactions.py +++ b/src/whop_sdk/resources/company_token_transactions.py @@ -32,8 +32,6 @@ class CompanyTokenTransactionsResource(SyncAPIResource): - """Company token transactions""" - @cached_property def with_raw_response(self) -> CompanyTokenTransactionsResourceWithRawResponse: """ @@ -367,8 +365,6 @@ 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 13d1ba92..9d8345bf 100644 --- a/src/whop_sdk/resources/course_chapters.py +++ b/src/whop_sdk/resources/course_chapters.py @@ -27,8 +27,6 @@ class CourseChaptersResource(SyncAPIResource): - """Course chapters""" - @cached_property def with_raw_response(self) -> CourseChaptersResourceWithRawResponse: """ @@ -276,8 +274,6 @@ 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 c162930e..19d49434 100644 --- a/src/whop_sdk/resources/course_lesson_interactions.py +++ b/src/whop_sdk/resources/course_lesson_interactions.py @@ -26,8 +26,6 @@ class CourseLessonInteractionsResource(SyncAPIResource): - """Course lesson interactions""" - @cached_property def with_raw_response(self) -> CourseLessonInteractionsResourceWithRawResponse: """ @@ -164,8 +162,6 @@ 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 710a739d..ef47ad3e 100644 --- a/src/whop_sdk/resources/course_lessons.py +++ b/src/whop_sdk/resources/course_lessons.py @@ -41,8 +41,6 @@ class CourseLessonsResource(SyncAPIResource): - """Course lessons""" - @cached_property def with_raw_response(self) -> CourseLessonsResourceWithRawResponse: """ @@ -495,8 +493,6 @@ 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 f85f1f82..83c1656e 100644 --- a/src/whop_sdk/resources/course_students.py +++ b/src/whop_sdk/resources/course_students.py @@ -26,8 +26,6 @@ class CourseStudentsResource(SyncAPIResource): - """Course students""" - @cached_property def with_raw_response(self) -> CourseStudentsResourceWithRawResponse: """ @@ -156,8 +154,6 @@ 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 9ea8d328..a5c5b25e 100644 --- a/src/whop_sdk/resources/courses.py +++ b/src/whop_sdk/resources/courses.py @@ -29,8 +29,6 @@ class CoursesResource(SyncAPIResource): - """Courses""" - @cached_property def with_raw_response(self) -> CoursesResourceWithRawResponse: """ @@ -361,8 +359,6 @@ 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 6ce07f13..03b47ef2 100644 --- a/src/whop_sdk/resources/dispute_alerts.py +++ b/src/whop_sdk/resources/dispute_alerts.py @@ -28,8 +28,6 @@ class DisputeAlertsResource(SyncAPIResource): - """Dispute alerts""" - @cached_property def with_raw_response(self) -> DisputeAlertsResourceWithRawResponse: """ @@ -171,8 +169,6 @@ 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 33d308f8..0baa88dc 100644 --- a/src/whop_sdk/resources/disputes.py +++ b/src/whop_sdk/resources/disputes.py @@ -28,8 +28,6 @@ class DisputesResource(SyncAPIResource): - """Disputes""" - @cached_property def with_raw_response(self) -> DisputesResourceWithRawResponse: """ @@ -330,8 +328,6 @@ 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 6c979300..7e51c55e 100644 --- a/src/whop_sdk/resources/dm_channels.py +++ b/src/whop_sdk/resources/dm_channels.py @@ -27,8 +27,6 @@ class DmChannelsResource(SyncAPIResource): - """Dm channels""" - @cached_property def with_raw_response(self) -> DmChannelsResourceWithRawResponse: """ @@ -284,8 +282,6 @@ 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 1681c01b..f1a8ca12 100644 --- a/src/whop_sdk/resources/dm_members.py +++ b/src/whop_sdk/resources/dm_members.py @@ -35,8 +35,6 @@ class DmMembersResource(SyncAPIResource): - """Dm members""" - @cached_property def with_raw_response(self) -> DmMembersResourceWithRawResponse: """ @@ -299,8 +297,6 @@ 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 42e4218f..41d5d23c 100644 --- a/src/whop_sdk/resources/entries.py +++ b/src/whop_sdk/resources/entries.py @@ -31,8 +31,6 @@ class EntriesResource(SyncAPIResource): - """Entries""" - @cached_property def with_raw_response(self) -> EntriesResourceWithRawResponse: """ @@ -263,8 +261,6 @@ 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 531a200e..50542d1d 100644 --- a/src/whop_sdk/resources/experiences.py +++ b/src/whop_sdk/resources/experiences.py @@ -36,8 +36,6 @@ class ExperiencesResource(SyncAPIResource): - """Experiences""" - @cached_property def with_raw_response(self) -> ExperiencesResourceWithRawResponse: """ @@ -460,8 +458,6 @@ 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 9a9e94ba..9944dd2b 100644 --- a/src/whop_sdk/resources/fee_markups.py +++ b/src/whop_sdk/resources/fee_markups.py @@ -28,8 +28,6 @@ class FeeMarkupsResource(SyncAPIResource): - """Fee markups""" - @cached_property def with_raw_response(self) -> FeeMarkupsResourceWithRawResponse: """ @@ -221,8 +219,6 @@ 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 d481f6e8..5729ec7c 100644 --- a/src/whop_sdk/resources/files.py +++ b/src/whop_sdk/resources/files.py @@ -23,8 +23,6 @@ class FilesResource(SyncAPIResource): - """Files""" - @cached_property def with_raw_response(self) -> FilesResourceWithRawResponse: """ @@ -115,8 +113,6 @@ 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 589c172d..0acb986e 100644 --- a/src/whop_sdk/resources/forum_posts.py +++ b/src/whop_sdk/resources/forum_posts.py @@ -33,8 +33,6 @@ class ForumPostsResource(SyncAPIResource): - """Forum posts""" - @cached_property def with_raw_response(self) -> ForumPostsResourceWithRawResponse: """ @@ -67,7 +65,6 @@ 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. @@ -116,9 +113,6 @@ 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. @@ -146,7 +140,6 @@ def create( "paywall_currency": paywall_currency, "pinned": pinned, "poll": poll, - "rich_content": rich_content, "title": title, "visibility": visibility, }, @@ -334,8 +327,6 @@ def list( class AsyncForumPostsResource(AsyncAPIResource): - """Forum posts""" - @cached_property def with_raw_response(self) -> AsyncForumPostsResourceWithRawResponse: """ @@ -368,7 +359,6 @@ 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. @@ -417,9 +407,6 @@ 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. @@ -447,7 +434,6 @@ 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 b4f9e476..3159079e 100644 --- a/src/whop_sdk/resources/forums.py +++ b/src/whop_sdk/resources/forums.py @@ -29,8 +29,6 @@ class ForumsResource(SyncAPIResource): - """Forums""" - @cached_property def with_raw_response(self) -> ForumsResourceWithRawResponse: """ @@ -91,7 +89,6 @@ 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, @@ -111,9 +108,6 @@ 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 @@ -134,7 +128,6 @@ 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, @@ -218,8 +211,6 @@ def list( class AsyncForumsResource(AsyncAPIResource): - """Forums""" - @cached_property def with_raw_response(self) -> AsyncForumsResourceWithRawResponse: """ @@ -280,7 +271,6 @@ 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, @@ -300,9 +290,6 @@ 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 @@ -323,7 +310,6 @@ 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 017fa401..aec677fc 100644 --- a/src/whop_sdk/resources/invoices.py +++ b/src/whop_sdk/resources/invoices.py @@ -32,8 +32,6 @@ class InvoicesResource(SyncAPIResource): - """Invoices""" - @cached_property def with_raw_response(self) -> InvoicesResourceWithRawResponse: """ @@ -83,6 +81,7 @@ 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 @@ -156,6 +155,7 @@ 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,6 +229,7 @@ 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 @@ -301,6 +302,7 @@ 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 @@ -420,6 +422,7 @@ def retrieve( Required permissions: - `invoice:basic:read` + - `plan:basic:read` Args: extra_headers: Send extra headers @@ -443,10 +446,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, @@ -469,16 +472,17 @@ 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. @@ -514,10 +518,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, @@ -574,8 +578,6 @@ def void( class AsyncInvoicesResource(AsyncAPIResource): - """Invoices""" - @cached_property def with_raw_response(self) -> AsyncInvoicesResourceWithRawResponse: """ @@ -625,6 +627,7 @@ 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 @@ -698,6 +701,7 @@ 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 @@ -771,6 +775,7 @@ 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 @@ -843,6 +848,7 @@ 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 @@ -962,6 +968,7 @@ async def retrieve( Required permissions: - `invoice:basic:read` + - `plan:basic:read` Args: extra_headers: Send extra headers @@ -985,10 +992,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, @@ -1011,16 +1018,17 @@ 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. @@ -1056,10 +1064,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 fd31d3d3..df6f9929 100644 --- a/src/whop_sdk/resources/leads.py +++ b/src/whop_sdk/resources/leads.py @@ -27,8 +27,6 @@ class LeadsResource(SyncAPIResource): - """Leads""" - @cached_property def with_raw_response(self) -> LeadsResourceWithRawResponse: """ @@ -290,8 +288,6 @@ 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 cbbc4ee6..d213b5ca 100644 --- a/src/whop_sdk/resources/ledger_accounts.py +++ b/src/whop_sdk/resources/ledger_accounts.py @@ -20,8 +20,6 @@ class LedgerAccountsResource(SyncAPIResource): - """Ledger accounts""" - @cached_property def with_raw_response(self) -> LedgerAccountsResourceWithRawResponse: """ @@ -81,8 +79,6 @@ 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 a9d50568..811f248f 100644 --- a/src/whop_sdk/resources/members.py +++ b/src/whop_sdk/resources/members.py @@ -32,8 +32,6 @@ class MembersResource(SyncAPIResource): - """Members""" - @cached_property def with_raw_response(self) -> MembersResourceWithRawResponse: """ @@ -210,8 +208,6 @@ 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 bf123a17..22af0afb 100644 --- a/src/whop_sdk/resources/memberships.py +++ b/src/whop_sdk/resources/memberships.py @@ -13,7 +13,6 @@ 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 @@ -37,8 +36,6 @@ class MembershipsResource(SyncAPIResource): - """Memberships""" - @cached_property def with_raw_response(self) -> MembershipsResourceWithRawResponse: """ @@ -247,51 +244,6 @@ 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, @@ -310,7 +262,7 @@ def cancel( Required permissions: - - `membership:cancel` + - `member:manage` - `member:email:read` - `member:basic:read` @@ -467,8 +419,6 @@ def uncancel( class AsyncMembershipsResource(AsyncAPIResource): - """Memberships""" - @cached_property def with_raw_response(self) -> AsyncMembershipsResourceWithRawResponse: """ @@ -677,53 +627,6 @@ 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, @@ -742,7 +645,7 @@ async def cancel( Required permissions: - - `membership:cancel` + - `member:manage` - `member:email:read` - `member:basic:read` @@ -913,9 +816,6 @@ 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, ) @@ -943,9 +843,6 @@ 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, ) @@ -973,9 +870,6 @@ 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, ) @@ -1003,9 +897,6 @@ 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 06ba3f0b..73316027 100644 --- a/src/whop_sdk/resources/messages.py +++ b/src/whop_sdk/resources/messages.py @@ -28,8 +28,6 @@ class MessagesResource(SyncAPIResource): - """Messages""" - @cached_property def with_raw_response(self) -> MessagesResourceWithRawResponse: """ @@ -315,8 +313,6 @@ 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 eaf1c066..f1eff29a 100644 --- a/src/whop_sdk/resources/notifications.py +++ b/src/whop_sdk/resources/notifications.py @@ -25,8 +25,6 @@ class NotificationsResource(SyncAPIResource): - """Notifications""" - @cached_property def with_raw_response(self) -> NotificationsResourceWithRawResponse: """ @@ -210,8 +208,6 @@ 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 9e9da3d2..9e993655 100644 --- a/src/whop_sdk/resources/payment_methods.py +++ b/src/whop_sdk/resources/payment_methods.py @@ -28,8 +28,6 @@ class PaymentMethodsResource(SyncAPIResource): - """Payment methods""" - @cached_property def with_raw_response(self) -> PaymentMethodsResourceWithRawResponse: """ @@ -196,8 +194,6 @@ 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 47e0be4c..d36041da 100644 --- a/src/whop_sdk/resources/payments.py +++ b/src/whop_sdk/resources/payments.py @@ -34,8 +34,6 @@ class PaymentsResource(SyncAPIResource): - """Payments""" - @cached_property def with_raw_response(self) -> PaymentsResourceWithRawResponse: """ @@ -590,8 +588,6 @@ 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 d0c5978d..0333f57e 100644 --- a/src/whop_sdk/resources/payout_methods.py +++ b/src/whop_sdk/resources/payout_methods.py @@ -26,8 +26,6 @@ class PayoutMethodsResource(SyncAPIResource): - """Payout methods""" - @cached_property def with_raw_response(self) -> PayoutMethodsResourceWithRawResponse: """ @@ -150,8 +148,6 @@ 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 fbd116c4..413c3f89 100644 --- a/src/whop_sdk/resources/plans.py +++ b/src/whop_sdk/resources/plans.py @@ -36,8 +36,6 @@ class PlansResource(SyncAPIResource): - """Plans""" - @cached_property def with_raw_response(self) -> PlansResourceWithRawResponse: """ @@ -506,8 +504,6 @@ 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 0c34deb9..a4b6793a 100644 --- a/src/whop_sdk/resources/products.py +++ b/src/whop_sdk/resources/products.py @@ -35,8 +35,6 @@ class ProductsResource(SyncAPIResource): - """Products""" - @cached_property def with_raw_response(self) -> ProductsResourceWithRawResponse: """ @@ -455,8 +453,6 @@ 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 5bb3b5d3..4d8deb2f 100644 --- a/src/whop_sdk/resources/promo_codes.py +++ b/src/whop_sdk/resources/promo_codes.py @@ -31,8 +31,6 @@ class PromoCodesResource(SyncAPIResource): - """Promo codes""" - @cached_property def with_raw_response(self) -> PromoCodesResourceWithRawResponse: """ @@ -327,8 +325,6 @@ 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 901f51a8..46882546 100644 --- a/src/whop_sdk/resources/reactions.py +++ b/src/whop_sdk/resources/reactions.py @@ -27,8 +27,6 @@ class ReactionsResource(SyncAPIResource): - """Reactions""" - @cached_property def with_raw_response(self) -> ReactionsResourceWithRawResponse: """ @@ -254,8 +252,6 @@ 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 e9bc15a9..ed7ba09f 100644 --- a/src/whop_sdk/resources/refunds.py +++ b/src/whop_sdk/resources/refunds.py @@ -28,8 +28,6 @@ class RefundsResource(SyncAPIResource): - """Refunds""" - @cached_property def with_raw_response(self) -> RefundsResourceWithRawResponse: """ @@ -167,8 +165,6 @@ 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 096ed767..3ce2c4d7 100644 --- a/src/whop_sdk/resources/reviews.py +++ b/src/whop_sdk/resources/reviews.py @@ -27,8 +27,6 @@ class ReviewsResource(SyncAPIResource): - """Reviews""" - @cached_property def with_raw_response(self) -> ReviewsResourceWithRawResponse: """ @@ -159,8 +157,6 @@ 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 71e5989c..e85baf44 100644 --- a/src/whop_sdk/resources/setup_intents.py +++ b/src/whop_sdk/resources/setup_intents.py @@ -28,8 +28,6 @@ class SetupIntentsResource(SyncAPIResource): - """Setup intents""" - @cached_property def with_raw_response(self) -> SetupIntentsResourceWithRawResponse: """ @@ -169,8 +167,6 @@ 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 e6b88fe8..1b46c631 100644 --- a/src/whop_sdk/resources/shipments.py +++ b/src/whop_sdk/resources/shipments.py @@ -26,8 +26,6 @@ class ShipmentsResource(SyncAPIResource): - """Shipments""" - @cached_property def with_raw_response(self) -> ShipmentsResourceWithRawResponse: """ @@ -215,8 +213,6 @@ 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 4fba5053..7b5146ae 100644 --- a/src/whop_sdk/resources/support_channels.py +++ b/src/whop_sdk/resources/support_channels.py @@ -28,8 +28,6 @@ class SupportChannelsResource(SyncAPIResource): - """Support channels""" - @cached_property def with_raw_response(self) -> SupportChannelsResourceWithRawResponse: """ @@ -219,8 +217,6 @@ 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 8dd55658..858cd891 100644 --- a/src/whop_sdk/resources/topups.py +++ b/src/whop_sdk/resources/topups.py @@ -23,8 +23,6 @@ class TopupsResource(SyncAPIResource): - """Topups""" - @cached_property def with_raw_response(self) -> TopupsResourceWithRawResponse: """ @@ -103,8 +101,6 @@ 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 9837e10c..6252141a 100644 --- a/src/whop_sdk/resources/transfers.py +++ b/src/whop_sdk/resources/transfers.py @@ -30,8 +30,6 @@ class TransfersResource(SyncAPIResource): - """Transfers""" - @cached_property def with_raw_response(self) -> TransfersResourceWithRawResponse: """ @@ -249,8 +247,6 @@ 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 4d01d560..914efd00 100644 --- a/src/whop_sdk/resources/users.py +++ b/src/whop_sdk/resources/users.py @@ -25,8 +25,6 @@ class UsersResource(SyncAPIResource): - """Users""" - @cached_property def with_raw_response(self) -> UsersResourceWithRawResponse: """ @@ -174,8 +172,6 @@ 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 829e8aa5..02f4b65d 100644 --- a/src/whop_sdk/resources/verifications.py +++ b/src/whop_sdk/resources/verifications.py @@ -20,8 +20,6 @@ class VerificationsResource(SyncAPIResource): - """Verifications""" - @cached_property def with_raw_response(self) -> VerificationsResourceWithRawResponse: """ @@ -80,8 +78,6 @@ 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 b396c301..340e6a65 100644 --- a/src/whop_sdk/resources/webhooks.py +++ b/src/whop_sdk/resources/webhooks.py @@ -34,8 +34,6 @@ class WebhooksResource(SyncAPIResource): - """Webhooks""" - @cached_property def with_raw_response(self) -> WebhooksResourceWithRawResponse: """ @@ -348,8 +346,6 @@ 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 3e6895cb..51b74257 100644 --- a/src/whop_sdk/resources/withdrawals.py +++ b/src/whop_sdk/resources/withdrawals.py @@ -29,8 +29,6 @@ class WithdrawalsResource(SyncAPIResource): - """Withdrawals""" - @cached_property def with_raw_response(self) -> WithdrawalsResourceWithRawResponse: """ @@ -231,8 +229,6 @@ 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 c2af8893..6d305f1a 100644 --- a/src/whop_sdk/types/__init__.py +++ b/src/whop_sdk/types/__init__.py @@ -139,11 +139,9 @@ 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 @@ -280,8 +278,6 @@ 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 @@ -297,10 +293,7 @@ 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 4eee3a32..9b147c0e 100644 --- a/src/whop_sdk/types/ai_chat_create_params.py +++ b/src/whop_sdk/types/ai_chat_create_params.py @@ -27,12 +27,6 @@ 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 deleted file mode 100644 index b2b538a5..00000000 --- a/src/whop_sdk/types/authorized_user_create_params.py +++ /dev/null @@ -1,27 +0,0 @@ -# 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 deleted file mode 100644 index 1bf69abd..00000000 --- a/src/whop_sdk/types/authorized_user_create_response.py +++ /dev/null @@ -1,55 +0,0 @@ -# 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 deleted file mode 100644 index ead84a1b..00000000 --- a/src/whop_sdk/types/authorized_user_delete_params.py +++ /dev/null @@ -1,16 +0,0 @@ -# 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 deleted file mode 100644 index b71b66f0..00000000 --- a/src/whop_sdk/types/authorized_user_delete_response.py +++ /dev/null @@ -1,7 +0,0 @@ -# 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 089fdafe..c475d5fb 100644 --- a/src/whop_sdk/types/company_update_params.py +++ b/src/whop_sdk/types/company_update_params.py @@ -2,12 +2,10 @@ from __future__ import annotations -from typing import Iterable, Optional +from typing import Optional from typing_extensions import Required, TypedDict -from .social_link_websites import SocialLinkWebsites - -__all__ = ["CompanyUpdateParams", "BannerImage", "Logo", "SocialLink", "SocialLinkImage"] +__all__ = ["CompanyUpdateParams", "BannerImage", "Logo"] class CompanyUpdateParams(TypedDict, total=False): @@ -36,13 +34,6 @@ 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 @@ -65,32 +56,3 @@ 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 6b8281a8..217521fc 100644 --- a/src/whop_sdk/types/forum_post_create_params.py +++ b/src/whop_sdk/types/forum_post_create_params.py @@ -63,12 +63,6 @@ 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 4cbd7083..4bb4f301 100644 --- a/src/whop_sdk/types/forum_post_list_response.py +++ b/src/whop_sdk/types/forum_post_list_response.py @@ -1,37 +1,11 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. -from typing import List, Optional +from typing import Optional from datetime import datetime from .._models import BaseModel -__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. - """ +__all__ = ["ForumPostListResponse", "User"] class User(BaseModel): @@ -62,9 +36,6 @@ 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 259496ec..2e2a97bc 100644 --- a/src/whop_sdk/types/forum_update_params.py +++ b/src/whop_sdk/types/forum_update_params.py @@ -3,22 +3,16 @@ from __future__ import annotations from typing import Optional -from typing_extensions import Required, TypedDict +from typing_extensions import 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", "BannerImage"] +__all__ = ["ForumUpdateParams"] 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""" @@ -27,13 +21,3 @@ 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 65c36fae..a3c6104b 100644 --- a/src/whop_sdk/types/invoice_create_params.py +++ b/src/whop_sdk/types/invoice_create_params.py @@ -2,14 +2,13 @@ from __future__ import annotations -from typing import List, Union, Iterable, Optional +from typing import 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 @@ -18,21 +17,17 @@ "CreateInvoiceInputWithProductAndMemberID", "CreateInvoiceInputWithProductAndMemberIDPlan", "CreateInvoiceInputWithProductAndMemberIDPlanCustomField", - "CreateInvoiceInputWithProductAndMemberIDPlanPaymentMethodConfiguration", "CreateInvoiceInputWithProductAndMemberIDProduct", "CreateInvoiceInputWithProductAndEmailAddress", "CreateInvoiceInputWithProductAndEmailAddressPlan", "CreateInvoiceInputWithProductAndEmailAddressPlanCustomField", - "CreateInvoiceInputWithProductAndEmailAddressPlanPaymentMethodConfiguration", "CreateInvoiceInputWithProductAndEmailAddressProduct", "CreateInvoiceInputWithProductIDAndMemberID", "CreateInvoiceInputWithProductIDAndMemberIDPlan", "CreateInvoiceInputWithProductIDAndMemberIDPlanCustomField", - "CreateInvoiceInputWithProductIDAndMemberIDPlanPaymentMethodConfiguration", "CreateInvoiceInputWithProductIDAndEmailAddress", "CreateInvoiceInputWithProductIDAndEmailAddressPlan", "CreateInvoiceInputWithProductIDAndEmailAddressPlanCustomField", - "CreateInvoiceInputWithProductIDAndEmailAddressPlanPaymentMethodConfiguration", ] @@ -118,34 +113,6 @@ 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. @@ -177,15 +144,6 @@ 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""" @@ -311,34 +269,6 @@ 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. @@ -370,15 +300,6 @@ 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""" @@ -500,34 +421,6 @@ 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. @@ -559,15 +452,6 @@ 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""" @@ -677,34 +561,6 @@ 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. @@ -736,15 +592,6 @@ 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 2adb1912..d1a4da26 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, Annotated, TypedDict +from typing_extensions import Literal, Required, Annotated, TypedDict from .._types import SequenceNotStr from .._utils import PropertyInfo @@ -16,6 +16,9 @@ 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.""" @@ -25,9 +28,6 @@ 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 deleted file mode 100644 index 568b654b..00000000 --- a/src/whop_sdk/types/membership_add_free_days_params.py +++ /dev/null @@ -1,16 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from __future__ import annotations - -from typing_extensions import Required, TypedDict - -__all__ = ["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 f6652e99..92e9660e 100644 --- a/src/whop_sdk/types/message_list_response.py +++ b/src/whop_sdk/types/message_list_response.py @@ -87,15 +87,6 @@ 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 6ba171dd..438f5ecd 100644 --- a/src/whop_sdk/types/payment_list_response.py +++ b/src/whop_sdk/types/payment_list_response.py @@ -9,7 +9,6 @@ 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 @@ -346,15 +345,6 @@ 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 1a74b27a..c61cc63f 100644 --- a/src/whop_sdk/types/payment_method_types.py +++ b/src/whop_sdk/types/payment_method_types.py @@ -25,7 +25,6 @@ "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 748a6e2f..c2ba590b 100644 --- a/src/whop_sdk/types/payment_provider.py +++ b/src/whop_sdk/types/payment_provider.py @@ -17,5 +17,4 @@ "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 deleted file mode 100644 index 3d0ea68a..00000000 --- a/src/whop_sdk/types/receipt_tax_behavior.py +++ /dev/null @@ -1,7 +0,0 @@ -# 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 3d2d9655..cd83e28c 100644 --- a/src/whop_sdk/types/refund_created_webhook_event.py +++ b/src/whop_sdk/types/refund_created_webhook_event.py @@ -11,7 +11,6 @@ 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 @@ -113,18 +112,6 @@ 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 57fc6384..973ec6c3 100644 --- a/src/whop_sdk/types/refund_retrieve_response.py +++ b/src/whop_sdk/types/refund_retrieve_response.py @@ -10,7 +10,6 @@ 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 @@ -105,18 +104,6 @@ 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 c5000b31..c7d7c86e 100644 --- a/src/whop_sdk/types/refund_updated_webhook_event.py +++ b/src/whop_sdk/types/refund_updated_webhook_event.py @@ -11,7 +11,6 @@ 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 @@ -113,18 +112,6 @@ 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 10d0fe2c..877db6d2 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", "custom" + "owner", "admin", "sales_manager", "moderator", "app_manager", "support", "manager" ] diff --git a/src/whop_sdk/types/shared/company.py b/src/whop_sdk/types/shared/company.py index 6f4bf53e..e30b8c1d 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: SocialLinkWebsites + website: Literal["x", "instagram", "facebook", "tiktok", "youtube", "linkedin", "twitch", "website", "custom"] """The website""" diff --git a/src/whop_sdk/types/shared/forum_post.py b/src/whop_sdk/types/shared/forum_post.py index 7a6136d7..d3af3981 100644 --- a/src/whop_sdk/types/shared/forum_post.py +++ b/src/whop_sdk/types/shared/forum_post.py @@ -1,37 +1,11 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. -from typing import List, Optional +from typing import Optional from datetime import datetime from ..._models import BaseModel -__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. - """ +__all__ = ["ForumPost", "User"] class User(BaseModel): @@ -62,9 +36,6 @@ 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 a24f502d..5b0ad97d 100644 --- a/src/whop_sdk/types/shared/message.py +++ b/src/whop_sdk/types/shared/message.py @@ -87,15 +87,6 @@ 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 6993b54d..07f5c8d5 100644 --- a/src/whop_sdk/types/shared/payment.py +++ b/src/whop_sdk/types/shared/payment.py @@ -13,7 +13,6 @@ 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__ = [ @@ -510,18 +509,6 @@ 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 c61f3cc6..2235fde7 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", "custom" + "owner", "admin", "sales_manager", "moderator", "app_manager", "support", "manager" ] diff --git a/src/whop_sdk/types/social_link_websites.py b/src/whop_sdk/types/social_link_websites.py deleted file mode 100644 index 7e96a15d..00000000 --- a/src/whop_sdk/types/social_link_websites.py +++ /dev/null @@ -1,9 +0,0 @@ -# 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 3f155d29..8681f573 100644 --- a/tests/api_resources/test_ai_chats.py +++ b/tests/api_resources/test_ai_chats.py @@ -38,7 +38,6 @@ 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"]) @@ -266,7 +265,6 @@ 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 945730cd..a0e6a63f 100644 --- a/tests/api_resources/test_authorized_users.py +++ b/tests/api_resources/test_authorized_users.py @@ -11,8 +11,6 @@ from tests.utils import assert_matches_type from whop_sdk.types import ( AuthorizedUserListResponse, - AuthorizedUserCreateResponse, - AuthorizedUserDeleteResponse, AuthorizedUserRetrieveResponse, ) from whop_sdk._utils import parse_datetime @@ -24,57 +22,6 @@ 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: @@ -161,114 +108,12 @@ 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: @@ -354,54 +199,3 @@ 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 707ad468..30eb5ebd 100644 --- a/tests/api_resources/test_companies.py +++ b/tests/api_resources/test_companies.py @@ -130,16 +130,6 @@ 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", ) @@ -336,16 +326,6 @@ 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 c02f5b99..ead26f5a 100644 --- a/tests/api_resources/test_forum_posts.py +++ b/tests/api_resources/test_forum_posts.py @@ -50,7 +50,6 @@ def test_method_create_with_all_params(self, client: Whop) -> None: } ] }, - rich_content="rich_content", title="title", visibility="members_only", ) @@ -262,7 +261,6 @@ 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 1b1fdfea..eef1173c 100644 --- a/tests/api_resources/test_forums.py +++ b/tests/api_resources/test_forums.py @@ -74,7 +74,6 @@ 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", @@ -223,7 +222,6 @@ 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 8ff6287c..7db7c125 100644 --- a/tests/api_resources/test_invoices.py +++ b/tests/api_resources/test_invoices.py @@ -57,12 +57,6 @@ 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, @@ -156,12 +150,6 @@ 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, @@ -255,12 +243,6 @@ 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, @@ -351,12 +333,6 @@ 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, @@ -455,17 +431,19 @@ 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() + invoice = client.invoices.list( + company_id="biz_xxxxxxxxxxxxxx", + ) 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", @@ -480,7 +458,9 @@ 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() + response = client.invoices.with_raw_response.list( + company_id="biz_xxxxxxxxxxxxxx", + ) assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" @@ -490,7 +470,9 @@ 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() as response: + with client.invoices.with_streaming_response.list( + company_id="biz_xxxxxxxxxxxxxx", + ) as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" @@ -584,12 +566,6 @@ 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, @@ -683,12 +659,6 @@ 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, @@ -782,12 +752,6 @@ 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, @@ -878,12 +842,6 @@ 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, @@ -982,17 +940,19 @@ 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() + invoice = await async_client.invoices.list( + company_id="biz_xxxxxxxxxxxxxx", + ) 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", @@ -1007,7 +967,9 @@ 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() + response = await async_client.invoices.with_raw_response.list( + company_id="biz_xxxxxxxxxxxxxx", + ) assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" @@ -1017,7 +979,9 @@ 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() as response: + async with async_client.invoices.with_streaming_response.list( + company_id="biz_xxxxxxxxxxxxxx", + ) 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 69df8fcd..2972632c 100644 --- a/tests/api_resources/test_memberships.py +++ b/tests/api_resources/test_memberships.py @@ -165,52 +165,6 @@ 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: @@ -546,52 +500,6 @@ 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 fb41f430..be74c103 100644 --- a/tests/api_resources/test_webhooks.py +++ b/tests/api_resources/test_webhooks.py @@ -257,20 +257,9 @@ def test_path_params_delete(self, client: Whop) -> None: "", ) - @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) + def test_method_unwrap(self, client: Whop) -> None: + key = b"secret" + hook = standardwebhooks.Webhook(key) 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" @@ -283,7 +272,7 @@ def test_method_unwrap(self, client: Whop, client_opt: str | None, method_opt: s } try: - _ = client.webhooks.unwrap(data, headers=headers, key=method_opt) + _ = client.webhooks.unwrap(data, headers=headers, key=key) except standardwebhooks.WebhookVerificationError as e: raise AssertionError("Failed to unwrap valid webhook") from e @@ -294,7 +283,7 @@ def test_method_unwrap(self, client: Whop, client_opt: str | None, method_opt: s ] for bad_header in bad_headers: with pytest.raises(standardwebhooks.WebhookVerificationError): - _ = client.webhooks.unwrap(data, headers=bad_header, key=method_opt) + _ = client.webhooks.unwrap(data, headers=bad_header, key=key) class TestAsyncWebhooks: @@ -534,20 +523,9 @@ async def test_path_params_delete(self, async_client: AsyncWhop) -> None: "", ) - @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) + def test_method_unwrap(self, client: Whop) -> None: + key = b"secret" + hook = standardwebhooks.Webhook(key) 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" @@ -560,7 +538,7 @@ def test_method_unwrap(self, async_client: Whop, client_opt: str | None, method_ } try: - _ = async_client.webhooks.unwrap(data, headers=headers, key=method_opt) + _ = client.webhooks.unwrap(data, headers=headers, key=key) except standardwebhooks.WebhookVerificationError as e: raise AssertionError("Failed to unwrap valid webhook") from e @@ -571,4 +549,4 @@ def test_method_unwrap(self, async_client: Whop, client_opt: str | None, method_ ] for bad_header in bad_headers: with pytest.raises(standardwebhooks.WebhookVerificationError): - _ = async_client.webhooks.unwrap(data, headers=bad_header, key=method_opt) + _ = client.webhooks.unwrap(data, headers=bad_header, key=key)