dub 0.29.2__py3-none-any.whl → 0.31.0__py3-none-any.whl

dub/_version.py

@@ -3,10 +3,10 @@
 import importlib.metadata
 
 __title__: str = "dub"
-__version__: str = "0.29.2"
+__version__: str = "0.31.0"
 __openapi_doc_version__: str = "0.0.1"
-__gen_version__: str = "2.698.4"
-__user_agent__: str = "speakeasy-sdk/python 0.29.2 2.698.4 0.0.1 dub"
+__gen_version__: str = "2.722.2"
+__user_agent__: str = "speakeasy-sdk/python 0.31.0 2.722.2 0.0.1 dub"
 
 try:
     if __package__ is not None:

dub/httpclient.py

@@ -107,7 +107,6 @@ def close_clients(
     # to them from the owning SDK instance and they can be reaped.
     owner.client = None
     owner.async_client = None
-
     if sync_client is not None and not sync_client_supplied:
         try:
             sync_client.close()

dub/models/components/__init__.py

@@ -58,11 +58,11 @@ if TYPE_CHECKING:
         CommissionCreatedEventData,
         CommissionCreatedEventDataTypedDict,
         CommissionCreatedEventEvent,
+        CommissionCreatedEventPartner,
+        CommissionCreatedEventPartnerTypedDict,
         CommissionCreatedEventStatus,
         CommissionCreatedEventType,
         CommissionCreatedEventTypedDict,
-        Partner,
-        PartnerTypedDict,
     )
     from .continentcode import ContinentCode
     from .domainschema import (
@@ -86,6 +86,8 @@ if TYPE_CHECKING:
         LeadCreatedEventTestVariants,
         LeadCreatedEventTestVariantsTypedDict,
         LeadCreatedEventTypedDict,
+        Partner,
+        PartnerTypedDict,
     )
     from .leadevent import (
         Customer,
@@ -167,6 +169,8 @@ if TYPE_CHECKING:
         SaleCreatedEventEvent,
         SaleCreatedEventLink,
         SaleCreatedEventLinkTypedDict,
+        SaleCreatedEventPartner,
+        SaleCreatedEventPartnerTypedDict,
         SaleCreatedEventSale,
         SaleCreatedEventSaleTypedDict,
         SaleCreatedEventTestVariants,
@@ -250,6 +254,8 @@ __all__ = [
     "CommissionCreatedEventData",
     "CommissionCreatedEventDataTypedDict",
     "CommissionCreatedEventEvent",
+    "CommissionCreatedEventPartner",
+    "CommissionCreatedEventPartnerTypedDict",
     "CommissionCreatedEventStatus",
     "CommissionCreatedEventType",
     "CommissionCreatedEventTypedDict",
@@ -344,6 +350,8 @@ __all__ = [
     "SaleCreatedEventEvent",
     "SaleCreatedEventLink",
     "SaleCreatedEventLinkTypedDict",
+    "SaleCreatedEventPartner",
+    "SaleCreatedEventPartnerTypedDict",
     "SaleCreatedEventSale",
     "SaleCreatedEventSaleTypedDict",
     "SaleCreatedEventTestVariants",
@@ -429,11 +437,11 @@ _dynamic_imports: dict[str, str] = {
     "CommissionCreatedEventData": ".commissioncreatedevent",
     "CommissionCreatedEventDataTypedDict": ".commissioncreatedevent",
     "CommissionCreatedEventEvent": ".commissioncreatedevent",
+    "CommissionCreatedEventPartner": ".commissioncreatedevent",
+    "CommissionCreatedEventPartnerTypedDict": ".commissioncreatedevent",
     "CommissionCreatedEventStatus": ".commissioncreatedevent",
     "CommissionCreatedEventType": ".commissioncreatedevent",
     "CommissionCreatedEventTypedDict": ".commissioncreatedevent",
-    "Partner": ".commissioncreatedevent",
-    "PartnerTypedDict": ".commissioncreatedevent",
     "ContinentCode": ".continentcode",
     "DomainSchema": ".domainschema",
     "DomainSchemaTypedDict": ".domainschema",
@@ -456,6 +464,8 @@ _dynamic_imports: dict[str, str] = {
     "LeadCreatedEventTestVariants": ".leadcreatedevent",
     "LeadCreatedEventTestVariantsTypedDict": ".leadcreatedevent",
     "LeadCreatedEventTypedDict": ".leadcreatedevent",
+    "Partner": ".leadcreatedevent",
+    "PartnerTypedDict": ".leadcreatedevent",
     "Customer": ".leadevent",
     "CustomerTypedDict": ".leadevent",
     "LeadEvent": ".leadevent",
@@ -521,6 +531,8 @@ _dynamic_imports: dict[str, str] = {
     "SaleCreatedEventEvent": ".salecreatedevent",
     "SaleCreatedEventLink": ".salecreatedevent",
     "SaleCreatedEventLinkTypedDict": ".salecreatedevent",
+    "SaleCreatedEventPartner": ".salecreatedevent",
+    "SaleCreatedEventPartnerTypedDict": ".salecreatedevent",
     "SaleCreatedEventSale": ".salecreatedevent",
     "SaleCreatedEventSaleTypedDict": ".salecreatedevent",
     "SaleCreatedEventTestVariants": ".salecreatedevent",

dub/models/components/commissioncreatedevent.py

@@ -30,7 +30,7 @@ class CommissionCreatedEventStatus(str, Enum):
     CANCELED = "canceled"
 
 
-class PartnerTypedDict(TypedDict):
+class CommissionCreatedEventPartnerTypedDict(TypedDict):
     id: str
     r"""The partner's unique ID on Dub."""
     name: str
@@ -51,7 +51,7 @@ class PartnerTypedDict(TypedDict):
     total_commissions: float
 
 
-class Partner(BaseModel):
+class CommissionCreatedEventPartner(BaseModel):
     id: str
     r"""The partner's unique ID on Dub."""
 
@@ -209,7 +209,7 @@ class CommissionCreatedEventDataTypedDict(TypedDict):
     quantity: float
     created_at: str
     updated_at: str
-    partner: PartnerTypedDict
+    partner: CommissionCreatedEventPartnerTypedDict
     type: NotRequired[CommissionCreatedEventType]
     user_id: NotRequired[Nullable[str]]
     r"""The user who created the manual commission."""
@@ -238,7 +238,7 @@ class CommissionCreatedEventData(BaseModel):
 
     updated_at: Annotated[str, pydantic.Field(alias="updatedAt")]
 
-    partner: Partner
+    partner: CommissionCreatedEventPartner
 
     type: Optional[CommissionCreatedEventType] = None
 

dub/models/components/leadcreatedevent.py

@@ -6,7 +6,7 @@ from dub.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTIN
 from enum import Enum
 import pydantic
 from pydantic import model_serializer
-from typing import Dict, List, Optional
+from typing import Any, Dict, List, Optional
 from typing_extensions import Annotated, NotRequired, TypedDict
 
 
@@ -491,11 +491,98 @@ class LeadCreatedEventLink(BaseModel):
         return m
 
 
+class PartnerTypedDict(TypedDict):
+    id: str
+    r"""The partner's unique ID on Dub."""
+    name: str
+    r"""The partner's full legal name."""
+    email: Nullable[str]
+    r"""The partner's email address. Should be a unique value across Dub."""
+    image: Nullable[str]
+    r"""The partner's avatar image."""
+    payouts_enabled_at: Nullable[str]
+    r"""The date when the partner enabled payouts."""
+    country: Nullable[str]
+    r"""The partner's country (required for tax purposes)."""
+    total_clicks: float
+    total_leads: float
+    total_conversions: float
+    total_sales: float
+    total_sale_amount: float
+    total_commissions: float
+
+
+class Partner(BaseModel):
+    id: str
+    r"""The partner's unique ID on Dub."""
+
+    name: str
+    r"""The partner's full legal name."""
+
+    email: Nullable[str]
+    r"""The partner's email address. Should be a unique value across Dub."""
+
+    image: Nullable[str]
+    r"""The partner's avatar image."""
+
+    payouts_enabled_at: Annotated[
+        Nullable[str], pydantic.Field(alias="payoutsEnabledAt")
+    ]
+    r"""The date when the partner enabled payouts."""
+
+    country: Nullable[str]
+    r"""The partner's country (required for tax purposes)."""
+
+    total_clicks: Annotated[float, pydantic.Field(alias="totalClicks")]
+
+    total_leads: Annotated[float, pydantic.Field(alias="totalLeads")]
+
+    total_conversions: Annotated[float, pydantic.Field(alias="totalConversions")]
+
+    total_sales: Annotated[float, pydantic.Field(alias="totalSales")]
+
+    total_sale_amount: Annotated[float, pydantic.Field(alias="totalSaleAmount")]
+
+    total_commissions: Annotated[float, pydantic.Field(alias="totalCommissions")]
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = []
+        nullable_fields = ["email", "image", "payoutsEnabledAt", "country"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            serialized.pop(k, None)
+
+            optional_nullable = k in optional_fields and k in nullable_fields
+            is_set = (
+                self.__pydantic_fields_set__.intersection({n})
+                or k in null_default_fields
+            )  # pylint: disable=no-member
+
+            if val is not None and val != UNSET_SENTINEL:
+                m[k] = val
+            elif val != UNSET_SENTINEL and (
+                not k in optional_fields or (optional_nullable and is_set)
+            ):
+                m[k] = val
+
+        return m
+
+
 class LeadCreatedEventDataTypedDict(TypedDict):
     event_name: str
     customer: LeadCreatedEventCustomerTypedDict
     click: LeadCreatedEventClickTypedDict
     link: LeadCreatedEventLinkTypedDict
+    metadata: Nullable[Dict[str, Any]]
+    partner: NotRequired[Nullable[PartnerTypedDict]]
 
 
 class LeadCreatedEventData(BaseModel):
@@ -507,6 +594,40 @@ class LeadCreatedEventData(BaseModel):
 
     link: LeadCreatedEventLink
 
+    metadata: Nullable[Dict[str, Any]]
+
+    partner: OptionalNullable[Partner] = UNSET
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["partner"]
+        nullable_fields = ["partner", "metadata"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            serialized.pop(k, None)
+
+            optional_nullable = k in optional_fields and k in nullable_fields
+            is_set = (
+                self.__pydantic_fields_set__.intersection({n})
+                or k in null_default_fields
+            )  # pylint: disable=no-member
+
+            if val is not None and val != UNSET_SENTINEL:
+                m[k] = val
+            elif val != UNSET_SENTINEL and (
+                not k in optional_fields or (optional_nullable and is_set)
+            ):
+                m[k] = val
+
+        return m
+
 
 class LeadCreatedEventTypedDict(TypedDict):
     r"""Triggered when a lead is created."""

dub/models/components/partnerenrolledevent.py

@@ -21,6 +21,7 @@ class Status(str, Enum):
     REJECTED = "rejected"
     INVITED = "invited"
     DECLINED = "declined"
+    DEACTIVATED = "deactivated"
     BANNED = "banned"
     ARCHIVED = "archived"
 
@@ -40,6 +41,8 @@ class PartnerEnrolledEventLinkTypedDict(TypedDict):
     r"""The number of clicks on the short link."""
     leads: NotRequired[float]
     r"""The number of leads the short link has generated."""
+    conversions: NotRequired[float]
+    r"""The number of leads that converted to paying customers."""
     sales: NotRequired[float]
     r"""The total number of sales (includes recurring sales) generated by the short link."""
     sale_amount: NotRequired[float]
@@ -68,6 +71,9 @@ class PartnerEnrolledEventLink(BaseModel):
     leads: Optional[float] = 0
     r"""The number of leads the short link has generated."""
 
+    conversions: Optional[float] = 0
+    r"""The number of leads that converted to paying customers."""
+
     sales: Optional[float] = 0
     r"""The total number of sales (includes recurring sales) generated by the short link."""
 
@@ -91,6 +97,8 @@ class PartnerEnrolledEventDataTypedDict(TypedDict):
     r"""The partner's unique ID on Dub."""
     name: str
     r"""The partner's full legal name."""
+    company_name: Nullable[str]
+    r"""If the partner profile type is a company, this is the partner's legal company name."""
     email: Nullable[str]
     r"""The partner's email address. Should be a unique value across Dub."""
     image: Nullable[str]
@@ -144,25 +152,16 @@ class PartnerEnrolledEventDataTypedDict(TypedDict):
     r"""The total net revenue generated by the partner. Defaults to 0 if `includeExpandedFields` is false."""
     website: NotRequired[Nullable[str]]
     r"""The partner's website URL (including the https protocol)."""
-    website_txt_record: NotRequired[Nullable[str]]
-    website_verified_at: NotRequired[Nullable[str]]
     youtube: NotRequired[Nullable[str]]
     r"""The partner's YouTube channel username (e.g. `johndoe`)."""
-    youtube_verified_at: NotRequired[Nullable[str]]
-    youtube_subscriber_count: NotRequired[Nullable[float]]
-    youtube_view_count: NotRequired[Nullable[float]]
     twitter: NotRequired[Nullable[str]]
     r"""The partner's Twitter username (e.g. `johndoe`)."""
-    twitter_verified_at: NotRequired[Nullable[str]]
     linkedin: NotRequired[Nullable[str]]
     r"""The partner's LinkedIn username (e.g. `johndoe`)."""
-    linkedin_verified_at: NotRequired[Nullable[str]]
     instagram: NotRequired[Nullable[str]]
     r"""The partner's Instagram username (e.g. `johndoe`)."""
-    instagram_verified_at: NotRequired[Nullable[str]]
     tiktok: NotRequired[Nullable[str]]
     r"""The partner's TikTok username (e.g. `johndoe`)."""
-    tiktok_verified_at: NotRequired[Nullable[str]]
 
 
 class PartnerEnrolledEventData(BaseModel):
@@ -172,6 +171,9 @@ class PartnerEnrolledEventData(BaseModel):
     name: str
     r"""The partner's full legal name."""
 
+    company_name: Annotated[Nullable[str], pydantic.Field(alias="companyName")]
+    r"""If the partner profile type is a company, this is the partner's legal company name."""
+
     email: Nullable[str]
     r"""The partner's email address. Should be a unique value across Dub."""
 
@@ -272,57 +274,21 @@ class PartnerEnrolledEventData(BaseModel):
     website: OptionalNullable[str] = UNSET
     r"""The partner's website URL (including the https protocol)."""
 
-    website_txt_record: Annotated[
-        OptionalNullable[str], pydantic.Field(alias="websiteTxtRecord")
-    ] = UNSET
-
-    website_verified_at: Annotated[
-        OptionalNullable[str], pydantic.Field(alias="websiteVerifiedAt")
-    ] = UNSET
-
     youtube: OptionalNullable[str] = UNSET
     r"""The partner's YouTube channel username (e.g. `johndoe`)."""
 
-    youtube_verified_at: Annotated[
-        OptionalNullable[str], pydantic.Field(alias="youtubeVerifiedAt")
-    ] = UNSET
-
-    youtube_subscriber_count: Annotated[
-        OptionalNullable[float], pydantic.Field(alias="youtubeSubscriberCount")
-    ] = UNSET
-
-    youtube_view_count: Annotated[
-        OptionalNullable[float], pydantic.Field(alias="youtubeViewCount")
-    ] = UNSET
-
     twitter: OptionalNullable[str] = UNSET
     r"""The partner's Twitter username (e.g. `johndoe`)."""
 
-    twitter_verified_at: Annotated[
-        OptionalNullable[str], pydantic.Field(alias="twitterVerifiedAt")
-    ] = UNSET
-
     linkedin: OptionalNullable[str] = UNSET
     r"""The partner's LinkedIn username (e.g. `johndoe`)."""
 
-    linkedin_verified_at: Annotated[
-        OptionalNullable[str], pydantic.Field(alias="linkedinVerifiedAt")
-    ] = UNSET
-
     instagram: OptionalNullable[str] = UNSET
     r"""The partner's Instagram username (e.g. `johndoe`)."""
 
-    instagram_verified_at: Annotated[
-        OptionalNullable[str], pydantic.Field(alias="instagramVerifiedAt")
-    ] = UNSET
-
     tiktok: OptionalNullable[str] = UNSET
     r"""The partner's TikTok username (e.g. `johndoe`)."""
 
-    tiktok_verified_at: Annotated[
-        OptionalNullable[str], pydantic.Field(alias="tiktokVerifiedAt")
-    ] = UNSET
-
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
         optional_fields = [
@@ -343,22 +309,14 @@ class PartnerEnrolledEventData(BaseModel):
             "saleAmount",
             "netRevenue",
             "website",
-            "websiteTxtRecord",
-            "websiteVerifiedAt",
             "youtube",
-            "youtubeVerifiedAt",
-            "youtubeSubscriberCount",
-            "youtubeViewCount",
             "twitter",
-            "twitterVerifiedAt",
             "linkedin",
-            "linkedinVerifiedAt",
             "instagram",
-            "instagramVerifiedAt",
             "tiktok",
-            "tiktokVerifiedAt",
         ]
         nullable_fields = [
+            "companyName",
             "email",
             "image",
             "description",
@@ -377,20 +335,11 @@ class PartnerEnrolledEventData(BaseModel):
             "bannedAt",
             "bannedReason",
             "website",
-            "websiteTxtRecord",
-            "websiteVerifiedAt",
             "youtube",
-            "youtubeVerifiedAt",
-            "youtubeSubscriberCount",
-            "youtubeViewCount",
             "twitter",
-            "twitterVerifiedAt",
             "linkedin",
-            "linkedinVerifiedAt",
             "instagram",
-            "instagramVerifiedAt",
             "tiktok",
-            "tiktokVerifiedAt",
         ]
         null_default_fields = []
 

dub/models/components/salecreatedevent.py

@@ -6,7 +6,7 @@ from dub.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTIN
 from enum import Enum
 import pydantic
 from pydantic import model_serializer
-from typing import Dict, List, Optional
+from typing import Any, Dict, List, Optional
 from typing_extensions import Annotated, NotRequired, TypedDict
 
 
@@ -538,12 +538,99 @@ class SaleCreatedEventSale(BaseModel):
         return m
 
 
+class SaleCreatedEventPartnerTypedDict(TypedDict):
+    id: str
+    r"""The partner's unique ID on Dub."""
+    name: str
+    r"""The partner's full legal name."""
+    email: Nullable[str]
+    r"""The partner's email address. Should be a unique value across Dub."""
+    image: Nullable[str]
+    r"""The partner's avatar image."""
+    payouts_enabled_at: Nullable[str]
+    r"""The date when the partner enabled payouts."""
+    country: Nullable[str]
+    r"""The partner's country (required for tax purposes)."""
+    total_clicks: float
+    total_leads: float
+    total_conversions: float
+    total_sales: float
+    total_sale_amount: float
+    total_commissions: float
+
+
+class SaleCreatedEventPartner(BaseModel):
+    id: str
+    r"""The partner's unique ID on Dub."""
+
+    name: str
+    r"""The partner's full legal name."""
+
+    email: Nullable[str]
+    r"""The partner's email address. Should be a unique value across Dub."""
+
+    image: Nullable[str]
+    r"""The partner's avatar image."""
+
+    payouts_enabled_at: Annotated[
+        Nullable[str], pydantic.Field(alias="payoutsEnabledAt")
+    ]
+    r"""The date when the partner enabled payouts."""
+
+    country: Nullable[str]
+    r"""The partner's country (required for tax purposes)."""
+
+    total_clicks: Annotated[float, pydantic.Field(alias="totalClicks")]
+
+    total_leads: Annotated[float, pydantic.Field(alias="totalLeads")]
+
+    total_conversions: Annotated[float, pydantic.Field(alias="totalConversions")]
+
+    total_sales: Annotated[float, pydantic.Field(alias="totalSales")]
+
+    total_sale_amount: Annotated[float, pydantic.Field(alias="totalSaleAmount")]
+
+    total_commissions: Annotated[float, pydantic.Field(alias="totalCommissions")]
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = []
+        nullable_fields = ["email", "image", "payoutsEnabledAt", "country"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            serialized.pop(k, None)
+
+            optional_nullable = k in optional_fields and k in nullable_fields
+            is_set = (
+                self.__pydantic_fields_set__.intersection({n})
+                or k in null_default_fields
+            )  # pylint: disable=no-member
+
+            if val is not None and val != UNSET_SENTINEL:
+                m[k] = val
+            elif val != UNSET_SENTINEL and (
+                not k in optional_fields or (optional_nullable and is_set)
+            ):
+                m[k] = val
+
+        return m
+
+
 class SaleCreatedEventDataTypedDict(TypedDict):
     event_name: str
     customer: SaleCreatedEventCustomerTypedDict
     click: SaleCreatedEventClickTypedDict
     link: SaleCreatedEventLinkTypedDict
     sale: SaleCreatedEventSaleTypedDict
+    metadata: Nullable[Dict[str, Any]]
+    partner: NotRequired[Nullable[SaleCreatedEventPartnerTypedDict]]
 
 
 class SaleCreatedEventData(BaseModel):
@@ -557,6 +644,40 @@ class SaleCreatedEventData(BaseModel):
 
     sale: SaleCreatedEventSale
 
+    metadata: Nullable[Dict[str, Any]]
+
+    partner: OptionalNullable[SaleCreatedEventPartner] = UNSET
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["partner"]
+        nullable_fields = ["partner", "metadata"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            serialized.pop(k, None)
+
+            optional_nullable = k in optional_fields and k in nullable_fields
+            is_set = (
+                self.__pydantic_fields_set__.intersection({n})
+                or k in null_default_fields
+            )  # pylint: disable=no-member
+
+            if val is not None and val != UNSET_SENTINEL:
+                m[k] = val
+            elif val != UNSET_SENTINEL and (
+                not k in optional_fields or (optional_nullable and is_set)
+            ):
+                m[k] = val
+
+        return m
+
 
 class SaleCreatedEventTypedDict(TypedDict):
     r"""Triggered when a sale is created."""

dub/models/components/workspaceschema.py

@@ -159,6 +159,8 @@ class WorkspaceSchemaTypedDict(TypedDict):
     r"""The miscellaneous key-value store of the workspace."""
     allowed_hostnames: Nullable[List[str]]
     r"""Specifies hostnames permitted for client-side click tracking."""
+    sso_email_domain: Nullable[str]
+    sso_enforced_at: Nullable[str]
     logo: NotRequired[Nullable[str]]
     r"""The logo of the workspace."""
     flags: NotRequired[Dict[str, bool]]
@@ -264,6 +266,10 @@ class WorkspaceSchema(BaseModel):
     ]
     r"""Specifies hostnames permitted for client-side click tracking."""
 
+    sso_email_domain: Annotated[Nullable[str], pydantic.Field(alias="ssoEmailDomain")]
+
+    sso_enforced_at: Annotated[Nullable[str], pydantic.Field(alias="ssoEnforcedAt")]
+
     logo: OptionalNullable[str] = None
     r"""The logo of the workspace."""
 
@@ -281,6 +287,8 @@ class WorkspaceSchema(BaseModel):
             "stripeConnectId",
             "store",
             "allowedHostnames",
+            "ssoEmailDomain",
+            "ssoEnforcedAt",
         ]
         null_default_fields = ["logo"]
 

dub/models/operations/createcustomer.py

@@ -17,6 +17,8 @@ class CreateCustomerRequestBodyTypedDict(TypedDict):
     r"""Name of the customer in the client's app. If not provided, a random name will be generated."""
     avatar: NotRequired[Nullable[str]]
     r"""Avatar URL of the customer in the client's app."""
+    stripe_customer_id: NotRequired[Nullable[str]]
+    r"""The customer's Stripe customer ID. Useful for attribution recurring sale events to the partner who referred the customer."""
 
 
 class CreateCustomerRequestBody(BaseModel):
@@ -32,10 +34,15 @@ class CreateCustomerRequestBody(BaseModel):
     avatar: OptionalNullable[str] = UNSET
     r"""Avatar URL of the customer in the client's app."""
 
+    stripe_customer_id: Annotated[
+        OptionalNullable[str], pydantic.Field(alias="stripeCustomerId")
+    ] = UNSET
+    r"""The customer's Stripe customer ID. Useful for attribution recurring sale events to the partner who referred the customer."""
+
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = ["email", "name", "avatar"]
-        nullable_fields = ["email", "name", "avatar"]
+        optional_fields = ["email", "name", "avatar", "stripeCustomerId"]
+        nullable_fields = ["email", "name", "avatar", "stripeCustomerId"]
         null_default_fields = []
 
         serialized = handler(self)
@@ -223,9 +230,9 @@ class CreateCustomerDiscount(BaseModel):
         optional_fields = ["description", "partnersCount"]
         nullable_fields = [
             "maxDuration",
-            "description",
             "couponId",
             "couponTestId",
+            "description",
             "partnersCount",
         ]
         null_default_fields = []