whop-sdk 0.0.10__py3-none-any.whl

whop_sdk/types/payment_create_params.py

@@ -0,0 +1,162 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union, Optional
+from typing_extensions import Required, TypeAlias, TypedDict
+
+from .shared.currency import Currency
+from .shared.plan_type import PlanType
+from .shared.visibility import Visibility
+from .shared.business_types import BusinessTypes
+from .shared.industry_types import IndustryTypes
+from .shared.global_affiliate_status import GlobalAffiliateStatus
+
+__all__ = [
+    "PaymentCreateParams",
+    "CreatePaymentInputWithPlan",
+    "CreatePaymentInputWithPlanPlan",
+    "CreatePaymentInputWithPlanPlanProduct",
+    "CreatePaymentInputWithPlanID",
+]
+
+
+class CreatePaymentInputWithPlan(TypedDict, total=False):
+    company_id: Required[str]
+    """The ID of the company to create the payment for."""
+
+    member_id: Required[str]
+    """The ID of the member to create the payment for."""
+
+    payment_token_id: Required[str]
+    """The ID of the payment token to use for the payment.
+
+    It must be connected to the Member being charged.
+    """
+
+    plan: Required[CreatePaymentInputWithPlanPlan]
+    """Pass this object to create a new plan for this payment"""
+
+
+class CreatePaymentInputWithPlanPlanProduct(TypedDict, total=False):
+    external_identifier: Required[str]
+    """A unique ID used to find or create a product.
+
+    When provided during creation, we will look for an existing product with this
+    external identifier — if found, it will be updated; otherwise, a new product
+    will be created.
+    """
+
+    title: Required[str]
+    """The title of the product."""
+
+    business_type: Optional[BusinessTypes]
+    """The different business types a company can be."""
+
+    collect_shipping_address: Optional[bool]
+    """Whether or not to collect shipping information at checkout from the customer."""
+
+    custom_statement_descriptor: Optional[str]
+    """The custom statement descriptor for the product i.e.
+
+    WHOP\\**SPORTS, must be between 5 and 22 characters, contain at least one letter,
+    and not contain any of the following characters: <, >, \\,, ', "
+    """
+
+    description: Optional[str]
+    """A written description of the product."""
+
+    global_affiliate_percentage: Optional[float]
+    """The percentage of the revenue that goes to the global affiliate program."""
+
+    global_affiliate_status: Optional[GlobalAffiliateStatus]
+    """The different statuses of the global affiliate program for a product."""
+
+    headline: Optional[str]
+    """The headline of the product."""
+
+    industry_type: Optional[IndustryTypes]
+    """The different industry types a company can be in."""
+
+    product_tax_code_id: Optional[str]
+    """The ID of the product tax code to apply to this product."""
+
+    redirect_purchase_url: Optional[str]
+    """The URL to redirect the customer to after a purchase."""
+
+    route: Optional[str]
+    """The route of the product."""
+
+    visibility: Optional[Visibility]
+    """Visibility of a resource"""
+
+
+class CreatePaymentInputWithPlanPlan(TypedDict, total=False):
+    currency: Required[Currency]
+    """The respective currency identifier for the plan."""
+
+    billing_period: Optional[int]
+    """The interval at which the plan charges (renewal plans)."""
+
+    description: Optional[str]
+    """The description of the plan."""
+
+    expiration_days: Optional[int]
+    """The interval at which the plan charges (expiration plans)."""
+
+    force_create_new_plan: Optional[bool]
+    """
+    Whether to force the creation of a new plan even if one with the same attributes
+    already exists.
+    """
+
+    initial_price: Optional[float]
+    """An additional amount charged upon first purchase."""
+
+    internal_notes: Optional[str]
+    """A personal description or notes section for the business."""
+
+    plan_type: Optional[PlanType]
+    """The type of plan that can be attached to a product"""
+
+    product: Optional[CreatePaymentInputWithPlanPlanProduct]
+    """Pass this object to create a new product for this plan.
+
+    We will use the product external identifier to find or create an existing
+    product.
+    """
+
+    product_id: Optional[str]
+    """The product the plan is related to. Either this or product is required."""
+
+    renewal_price: Optional[float]
+    """The amount the customer is charged every billing period."""
+
+    title: Optional[str]
+    """The title of the plan. This will be visible on the product page to customers."""
+
+    trial_period_days: Optional[int]
+    """The number of free trial days added before a renewal plan."""
+
+    visibility: Optional[Visibility]
+    """Visibility of a resource"""
+
+
+class CreatePaymentInputWithPlanID(TypedDict, total=False):
+    company_id: Required[str]
+    """The ID of the company to create the payment for."""
+
+    member_id: Required[str]
+    """The ID of the member to create the payment for."""
+
+    payment_token_id: Required[str]
+    """The ID of the payment token to use for the payment.
+
+    It must be connected to the Member being charged.
+    """
+
+    plan_id: Required[str]
+    """An ID of an existing plan to use for the payment."""
+
+
+PaymentCreateParams: TypeAlias = Union[CreatePaymentInputWithPlan, CreatePaymentInputWithPlanID]

whop_sdk/types/payment_failed_webhook_event.py

@@ -0,0 +1,26 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from datetime import datetime
+from typing_extensions import Literal
+
+from .._models import BaseModel
+from .shared.payment import Payment
+
+__all__ = ["PaymentFailedWebhookEvent"]
+
+
+class PaymentFailedWebhookEvent(BaseModel):
+    id: str
+    """A unique ID for every single webhook request"""
+
+    api_version: Literal["v1"]
+    """The API version for this webhook"""
+
+    data: Payment
+    """An object representing a receipt for a membership."""
+
+    timestamp: datetime
+    """The timestamp in ISO 8601 format that the webhook was sent at on the server"""
+
+    type: Literal["payment.failed"]
+    """The webhook event type"""

whop_sdk/types/payment_list_params.py

@@ -0,0 +1,67 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List, Union, Optional
+from datetime import datetime
+from typing_extensions import Literal, Required, Annotated, TypedDict
+
+from .._types import SequenceNotStr
+from .._utils import PropertyInfo
+from .billing_reasons import BillingReasons
+from .shared.currency import Currency
+from .shared.direction import Direction
+from .shared.receipt_status import ReceiptStatus
+from .shared.friendly_receipt_status import FriendlyReceiptStatus
+
+__all__ = ["PaymentListParams"]
+
+
+class PaymentListParams(TypedDict, total=False):
+    company_id: Required[str]
+    """The ID of the company to list payments for"""
+
+    after: Optional[str]
+    """Returns the elements in the list that come after the specified cursor."""
+
+    before: Optional[str]
+    """Returns the elements in the list that come before the specified cursor."""
+
+    billing_reasons: Optional[List[BillingReasons]]
+    """The billing reason for the payment"""
+
+    created_after: Annotated[Union[str, datetime, None], PropertyInfo(format="iso8601")]
+    """The minimum creation date to filter by"""
+
+    created_before: Annotated[Union[str, datetime, None], PropertyInfo(format="iso8601")]
+    """The maximum creation date to filter by"""
+
+    currencies: Optional[List[Currency]]
+    """The currency of the payment."""
+
+    direction: Optional[Direction]
+    """The direction of the sort."""
+
+    first: Optional[int]
+    """Returns the first _n_ elements from the list."""
+
+    include_free: Optional[bool]
+    """Whether to include free payments."""
+
+    last: Optional[int]
+    """Returns the last _n_ elements from the list."""
+
+    order: Optional[Literal["final_amount", "created_at", "paid_at"]]
+    """The order to sort the results by."""
+
+    plan_ids: Optional[SequenceNotStr[str]]
+    """A specific plan."""
+
+    product_ids: Optional[SequenceNotStr[str]]
+    """A specific product."""
+
+    statuses: Optional[List[ReceiptStatus]]
+    """The status of the payment."""
+
+    substatuses: Optional[List[FriendlyReceiptStatus]]
+    """The substatus of the payment."""

whop_sdk/types/payment_list_response.py

@@ -0,0 +1,273 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, Optional
+from datetime import datetime
+
+from .._models import BaseModel
+from .card_brands import CardBrands
+from .billing_reasons import BillingReasons
+from .shared.currency import Currency
+from .shared.promo_type import PromoType
+from .payment_method_types import PaymentMethodTypes
+from .shared.receipt_status import ReceiptStatus
+from .shared.membership_status import MembershipStatus
+from .shared.friendly_receipt_status import FriendlyReceiptStatus
+
+__all__ = [
+    "PaymentListResponse",
+    "BillingAddress",
+    "Company",
+    "Member",
+    "Membership",
+    "PaymentToken",
+    "PaymentTokenCard",
+    "Plan",
+    "Product",
+    "PromoCode",
+    "User",
+]
+
+
+class BillingAddress(BaseModel):
+    city: Optional[str] = None
+    """The city of the address."""
+
+    country: Optional[str] = None
+    """The country of the address."""
+
+    line1: Optional[str] = None
+    """The line 1 of the address."""
+
+    line2: Optional[str] = None
+    """The line 2 of the address."""
+
+    name: Optional[str] = None
+    """The name of the customer."""
+
+    postal_code: Optional[str] = None
+    """The postal code of the address."""
+
+    state: Optional[str] = None
+    """The state of the address."""
+
+
+class Company(BaseModel):
+    id: str
+    """The ID of the company"""
+
+    route: str
+    """The slug/route of the company on the Whop site."""
+
+    title: str
+    """The written name of the company."""
+
+
+class Member(BaseModel):
+    id: str
+    """The ID of the member"""
+
+    phone: Optional[str] = None
+    """The phone number for the member, if available."""
+
+
+class Membership(BaseModel):
+    id: str
+    """The internal ID of the membership."""
+
+    status: MembershipStatus
+    """The state of the membership."""
+
+
+class PaymentTokenCard(BaseModel):
+    brand: Optional[CardBrands] = None
+    """Possible card brands that a payment token can have"""
+
+    exp_month: Optional[int] = None
+    """Card expiration month, like 03 for March."""
+
+    exp_year: Optional[int] = None
+    """Card expiration year, like 27 for 2027."""
+
+    last4: Optional[str] = None
+    """Last four digits of the card."""
+
+
+class PaymentToken(BaseModel):
+    id: str
+    """The ID of the payment token"""
+
+    card: Optional[PaymentTokenCard] = None
+    """
+    The card data associated with the payment token, if its a debit or credit card
+    token.
+    """
+
+    created_at: datetime
+    """The date and time the payment token was created"""
+
+    payment_method_type: PaymentMethodTypes
+    """The payment method type of the payment token"""
+
+
+class Plan(BaseModel):
+    id: str
+    """The internal ID of the plan."""
+
+
+class Product(BaseModel):
+    id: str
+    """The internal ID of the public product."""
+
+    route: str
+    """The route of the product."""
+
+    title: str
+    """The title of the product. Use for Whop 4.0."""
+
+
+class PromoCode(BaseModel):
+    id: str
+    """The ID of the promo."""
+
+    amount_off: float
+    """The amount off (% or flat amount) for the promo."""
+
+    base_currency: Currency
+    """The monetary currency of the promo code."""
+
+    code: Optional[str] = None
+    """The specific code used to apply the promo at checkout."""
+
+    number_of_intervals: Optional[int] = None
+    """The number of months the promo is applied for."""
+
+    promo_type: PromoType
+    """The type (% or flat amount) of the promo."""
+
+
+class User(BaseModel):
+    id: str
+    """The internal ID of the user."""
+
+    email: Optional[str] = None
+    """The email of the user"""
+
+    name: Optional[str] = None
+    """The name of the user from their Whop account."""
+
+    username: str
+    """The username of the user from their Whop account."""
+
+
+class PaymentListResponse(BaseModel):
+    id: str
+    """The payment ID"""
+
+    amount_after_fees: float
+    """How much the payment is for after fees"""
+
+    auto_refunded: bool
+    """Whether this payment was auto refunded or not"""
+
+    billing_address: Optional[BillingAddress] = None
+    """The address of the user who made the payment."""
+
+    billing_reason: Optional[BillingReasons] = None
+    """The reason why a specific payment was billed"""
+
+    card_brand: Optional[CardBrands] = None
+    """Possible card brands that a payment token can have"""
+
+    card_last4: Optional[str] = None
+    """The last 4 digits of the card used to make the payment."""
+
+    company: Optional[Company] = None
+    """The company for the payment."""
+
+    created_at: datetime
+    """The datetime the payment was created"""
+
+    currency: Optional[Currency] = None
+    """The available currencies on the platform"""
+
+    dispute_alerted_at: Optional[datetime] = None
+    """When an alert came in that this transaction will be disputed"""
+
+    failure_message: Optional[str] = None
+    """If the payment failed, the reason for the failure."""
+
+    last_payment_attempt: Optional[datetime] = None
+    """The time of the last payment attempt."""
+
+    member: Optional[Member] = None
+    """The member attached to this payment."""
+
+    membership: Optional[Membership] = None
+    """The membership attached to this payment."""
+
+    metadata: Optional[Dict[str, object]] = None
+    """The custom metadata stored on this payment.
+
+    This will be copied the checkout configuration for which this payment was made
+    """
+
+    paid_at: Optional[datetime] = None
+    """The datetime the payment was paid"""
+
+    payment_method_type: Optional[PaymentMethodTypes] = None
+    """The different types of payment methods that can be used."""
+
+    payment_token: Optional[PaymentToken] = None
+    """The payment token used for the payment, if available."""
+
+    plan: Optional[Plan] = None
+    """The plan attached to this payment."""
+
+    product: Optional[Product] = None
+    """The product this payment was made for"""
+
+    promo_code: Optional[PromoCode] = None
+    """The promo code used for this payment."""
+
+    refundable: bool
+    """
+    True only for payments that are `paid`, have not been fully refunded, and were
+    processed by a payment processor that allows refunds.
+    """
+
+    refunded_amount: Optional[float] = None
+    """The payment refund amount(if applicable)."""
+
+    refunded_at: Optional[datetime] = None
+    """When the payment was refunded (if applicable)."""
+
+    retryable: bool
+    """
+    True when the payment status is `open` and its membership is in one of the
+    retry-eligible states (`active`, `trialing`, `completed`, or `past_due`);
+    otherwise false. Used to decide if Whop can attempt the charge again.
+    """
+
+    status: Optional[ReceiptStatus] = None
+    """The status of a receipt"""
+
+    substatus: FriendlyReceiptStatus
+    """The friendly status of the payment."""
+
+    subtotal: Optional[float] = None
+    """The subtotal to show to the creator (excluding buyer fees)."""
+
+    total: Optional[float] = None
+    """The total to show to the creator (excluding buyer fees)."""
+
+    usd_total: Optional[float] = None
+    """The total in USD to show to the creator (excluding buyer fees)."""
+
+    user: Optional[User] = None
+    """The user that made this payment."""
+
+    voidable: bool
+    """
+    True when the payment is tied to a membership in `past_due`, the payment status
+    is `open`, and the processor allows voiding payments; otherwise false.
+    """

whop_sdk/types/payment_method_types.py

@@ -0,0 +1,94 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal, TypeAlias
+
+__all__ = ["PaymentMethodTypes"]
+
+PaymentMethodTypes: TypeAlias = Literal[
+    "acss_debit",
+    "affirm",
+    "afterpay_clearpay",
+    "alipay",
+    "alma",
+    "amazon_pay",
+    "apple_pay",
+    "au_becs_debit",
+    "bacs_debit",
+    "bancontact",
+    "billie",
+    "blik",
+    "boleto",
+    "card",
+    "cashapp",
+    "crypto",
+    "eps",
+    "fpx",
+    "giropay",
+    "google_pay",
+    "grabpay",
+    "ideal",
+    "kakao_pay",
+    "klarna",
+    "konbini",
+    "kr_card",
+    "link",
+    "mobilepay",
+    "multibanco",
+    "naver_pay",
+    "nz_bank_account",
+    "oxxo",
+    "p24",
+    "pay_by_bank",
+    "payco",
+    "paynow",
+    "pix",
+    "promptpay",
+    "revolut_pay",
+    "samsung_pay",
+    "satispay",
+    "sepa_debit",
+    "sofort",
+    "swish",
+    "twint",
+    "us_bank_account",
+    "wechat_pay",
+    "zip",
+    "bizum",
+    "capchase_pay",
+    "kriya",
+    "mondu",
+    "ng_wallet",
+    "paypay",
+    "sequra",
+    "scalapay",
+    "vipps",
+    "custom",
+    "customer_balance",
+    "gopay",
+    "mb_way",
+    "ng_bank",
+    "ng_bank_transfer",
+    "ng_card",
+    "ng_market",
+    "ng_ussd",
+    "paypal",
+    "payto",
+    "qris",
+    "rechnung",
+    "south_korea_market",
+    "kr_market",
+    "shopeepay",
+    "upi",
+    "sunbit",
+    "netbanking",
+    "id_bank_transfer",
+    "demo_pay",
+    "shop_pay",
+    "sezzle",
+    "coinbase",
+    "splitit",
+    "platform_balance",
+    "apple",
+    "venmo",
+    "unknown",
+]

whop_sdk/types/payment_pending_webhook_event.py

@@ -0,0 +1,26 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from datetime import datetime
+from typing_extensions import Literal
+
+from .._models import BaseModel
+from .shared.payment import Payment
+
+__all__ = ["PaymentPendingWebhookEvent"]
+
+
+class PaymentPendingWebhookEvent(BaseModel):
+    id: str
+    """A unique ID for every single webhook request"""
+
+    api_version: Literal["v1"]
+    """The API version for this webhook"""
+
+    data: Payment
+    """An object representing a receipt for a membership."""
+
+    timestamp: datetime
+    """The timestamp in ISO 8601 format that the webhook was sent at on the server"""
+
+    type: Literal["payment.pending"]
+    """The webhook event type"""

whop_sdk/types/payment_provider.py

@@ -0,0 +1,9 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal, TypeAlias
+
+__all__ = ["PaymentProvider"]
+
+PaymentProvider: TypeAlias = Literal[
+    "stripe", "coinbase", "paypal", "apple", "sezzle", "splitit", "platform_balance", "multi_psp"
+]

whop_sdk/types/payment_refund_params.py

@@ -0,0 +1,13 @@
+# 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__ = ["PaymentRefundParams"]
+
+
+class PaymentRefundParams(TypedDict, total=False):
+    partial_amount: Optional[float]
+    """An amount if the refund is supposed to be partial."""