otf-api 0.12.0__py3-none-any.whl → 0.13.0__py3-none-any.whl

otf_api/{filters.py → models/bookings/filters.py}

@@ -1,8 +1,9 @@
 from datetime import date, datetime, time
 
+import pendulum
 from pydantic import BaseModel, field_validator
 
-from otf_api.models import ClassType, DoW, OtfClass
+from otf_api.models.bookings import ClassType, DoW, OtfClass
 
 
 class ClassFilter(BaseModel):
@@ -28,11 +29,11 @@ class ClassFilter(BaseModel):
         start_time (list[time]): Filter classes by start time.
     """
 
-    start_date: date | None = None
-    end_date: date | None = None
-    class_type: list[ClassType] | None = None
-    day_of_week: list[DoW] | None = None
-    start_time: list[time] | None = None
+    start_date: date | str | None = None
+    end_date: date | str | None = None
+    class_type: list[ClassType] | ClassType | None = None
+    day_of_week: list[DoW] | DoW | None = None
+    start_time: list[time] | time | None = None
 
     def filter_classes(self, classes: list[OtfClass]) -> list[OtfClass]:
         """Filters a list of classes based on the filter arguments.
@@ -51,9 +52,11 @@ class ClassFilter(BaseModel):
             self.end_date = self.end_date.date()
 
         if self.start_date:
+            assert isinstance(self.start_date, date), "start_date must be a date object"
             classes = [c for c in classes if c.starts_at.date() >= self.start_date]
 
         if self.end_date:
+            assert isinstance(self.end_date, date), "end_date must be a date object"
             classes = [c for c in classes if c.starts_at.date() <= self.end_date]
 
         if self.class_type:
@@ -63,35 +66,60 @@ class ClassFilter(BaseModel):
             classes = [c for c in classes if c.day_of_week in self.day_of_week]
 
         if self.start_time:
+            assert isinstance(self.start_time, list), "start_time must be a list of time objects"
             classes = [c for c in classes if c.starts_at.time() in self.start_time]
 
         return classes
 
     @field_validator("class_type", "day_of_week", "start_time", mode="before")
     @classmethod
-    def _single_item_to_list(cls, v):
+    def _single_item_to_list(cls, v: str | list | None) -> list | None:
         if v and not isinstance(v, list):
             return [v]
+
+        if not v:
+            return None
+
         return v
 
     @field_validator("day_of_week", mode="before")
     @classmethod
-    def _day_of_week_str_to_enum(cls, v):
+    def _day_of_week_str_to_enum(cls, v: str | list[str] | None) -> list[DoW] | None:
         if v and isinstance(v, str):
             return [DoW(v.title())]
 
         if v and isinstance(v, list) and not all(isinstance(i, DoW) for i in v):
             return [DoW(i.title()) for i in v]
 
-        return v
+        if not v:
+            return None
+
+        return v  # type: ignore
 
     @field_validator("class_type", mode="before")
     @classmethod
-    def _class_type_str_to_enum(cls, v):
+    def _class_type_str_to_enum(cls, v: str | list[str] | None) -> list[ClassType] | None:
         if v and isinstance(v, str):
             return [ClassType.get_case_insensitive(v)]
 
         if v and isinstance(v, list) and not all(isinstance(i, ClassType) for i in v):
             return [ClassType.get_case_insensitive(i) for i in v]
 
-        return v
+        if not v:
+            return None
+
+        return v  # type: ignore
+
+    @field_validator("start_date", "end_date", mode="before")
+    @classmethod
+    def _date_string_to_date(cls, v: str | date | None) -> date | None:
+        if v is None:
+            return None
+        if isinstance(v, date):
+            return v
+
+        try:
+            value = pendulum.parse(v)
+            return value.date() if isinstance(value, datetime) else value  # type: ignore
+        except (ValueError, TypeError):
+            raise ValueError(f"Invalid date format: {v}. Expected format is YYYY-MM-DD or a date object.")

otf_api/models/{ratings.py → bookings/ratings.py}

@@ -9,9 +9,7 @@ CLASS_RATING_MAP = {0: 0, 1: 19, 2: 20, 3: 21}
 
 
 def get_class_rating_value(class_rating: int) -> int:
-    """
-    Convert the class rating from the old values to the new values.
-    """
+    """Convert the class rating from the old values to the new values."""
     if class_rating not in CLASS_RATING_MAP:
         raise ValueError(f"Invalid class rating {class_rating}")
 
@@ -19,9 +17,7 @@ def get_class_rating_value(class_rating: int) -> int:
 
 
 def get_coach_rating_value(coach_rating: int) -> int:
-    """
-    Convert the coach rating from the old values to the new values.
-    """
+    """Convert the coach rating from the old values to the new values."""
     if coach_rating not in COACH_RATING_MAP:
         raise ValueError(f"Invalid coach rating {coach_rating}")
 

otf_api/models/members/__init__.py

@@ -0,0 +1,5 @@
+from .member_detail import MemberDetail
+from .member_membership import MemberMembership
+from .member_purchases import MemberPurchase
+
+__all__ = ["MemberDetail", "MemberMembership", "MemberPurchase"]

otf_api/models/members/member_detail.py

@@ -0,0 +1,149 @@
+from datetime import date, datetime
+
+from pydantic import Field, field_validator
+
+from otf_api.models.base import OtfItemBase
+from otf_api.models.mixins import AddressMixin, ApiMixin
+from otf_api.models.studios.studio_detail import StudioDetail
+
+
+class Address(AddressMixin, OtfItemBase):
+    member_address_uuid: str | None = Field(None, validation_alias="memberAddressUUId", exclude=True, repr=False)
+    type: str | None = None
+
+
+class MemberProfile(OtfItemBase):
+    unit_of_measure: str | None = Field(None, validation_alias="unitOfMeasure")
+    max_hr_type: str | None = Field(None, validation_alias="maxHrType")
+    manual_max_hr: int | None = Field(None, validation_alias="manualMaxHr")
+    formula_max_hr: int | None = Field(None, validation_alias="formulaMaxHr")
+    automated_hr: int | None = Field(None, validation_alias="automatedHr")
+
+    member_profile_uuid: str | None = Field(None, validation_alias="memberProfileUUId", exclude=True, repr=False)
+    member_optin_flow_type_id: int | None = Field(
+        None, validation_alias="memberOptinFlowTypeId", exclude=True, repr=False
+    )
+
+
+class MemberClassSummary(OtfItemBase):
+    total_classes_booked: int | None = Field(None, validation_alias="totalClassesBooked")
+    total_classes_attended: int | None = Field(None, validation_alias="totalClassesAttended")
+    total_intro_classes: int | None = Field(None, validation_alias="totalIntro")
+    total_ot_live_classes_booked: int | None = Field(None, validation_alias="totalOTLiveClassesBooked")
+    total_ot_live_classes_attended: int | None = Field(None, validation_alias="totalOTLiveClassesAttended")
+    total_classes_used_hrm: int | None = Field(None, validation_alias="totalClassesUsedHRM")
+    total_studios_visited: int | None = Field(None, validation_alias="totalStudiosVisited")
+    first_visit_date: date | None = Field(None, validation_alias="firstVisitDate")
+    last_class_visited_date: date | None = Field(None, validation_alias="lastClassVisitedDate")
+    last_class_booked_date: date | None = Field(None, validation_alias="lastClassBookedDate")
+
+    last_class_studio_visited: int | None = Field(
+        None, validation_alias="lastClassStudioVisited", exclude=True, repr=False
+    )
+
+
+class MemberDetail(ApiMixin, OtfItemBase):
+    member_uuid: str = Field(..., validation_alias="memberUUId")
+    cognito_id: str = Field(
+        ...,
+        validation_alias="cognitoId",
+        exclude=True,
+        repr=False,
+        description="Cognito user ID, not necessary for end users. Also on OtfUser object.",
+    )
+
+    home_studio: StudioDetail
+    profile: MemberProfile = Field(..., validation_alias="memberProfile")
+    class_summary: MemberClassSummary | None = Field(None, validation_alias="memberClassSummary")
+    addresses: list[Address] | None = Field(default_factory=list)
+
+    studio_display_name: str | None = Field(
+        None,
+        validation_alias="userName",
+        description="The value that is displayed on tread/rower tablets and OTBeat screens",
+    )
+    first_name: str | None = Field(None, validation_alias="firstName")
+    last_name: str | None = Field(None, validation_alias="lastName")
+    email: str | None = Field(None, validation_alias="email")
+    phone_number: str | None = Field(None, validation_alias="phoneNumber")
+    birth_day: date | None = Field(None, validation_alias="birthDay")
+    gender: str | None = Field(None, validation_alias="gender")
+    locale: str | None = Field(None, validation_alias="locale")
+    weight: int | None = Field(None, validation_alias="weight")
+    weight_units: str | None = Field(None, validation_alias="weightMeasure")
+    height: int | None = Field(None, validation_alias="height")
+    height_units: str | None = Field(None, validation_alias="heightMeasure")
+
+    # unused fields - leaving these in for now in case someone finds a purpose for them
+    # but they will potentially (likely?) be removed in the future
+
+    # mbo fields
+    mbo_id: str | None = Field(None, validation_alias="mboId", exclude=True, repr=False, description="MindBody attr")
+    mbo_status: str | None = Field(
+        None, validation_alias="mboStatus", exclude=True, repr=False, description="MindBody attr"
+    )
+    mbo_studio_id: int | None = Field(
+        None, validation_alias="mboStudioId", exclude=True, repr=False, description="MindBody attr"
+    )
+    mbo_unique_id: int | None = Field(
+        None, validation_alias="mboUniqueId", exclude=True, repr=False, description="MindBody attr"
+    )
+
+    # ids
+    created_by: str | None = Field(None, validation_alias="createdBy", exclude=True, repr=False)
+    home_studio_id: int | None = Field(
+        None, validation_alias="homeStudioId", exclude=True, repr=False, description="Not used by API"
+    )
+    member_id: int | None = Field(
+        None, validation_alias="memberId", exclude=True, repr=False, description="Not used by API"
+    )
+    otf_acs_id: str | None = Field(None, validation_alias="otfAcsId", exclude=True, repr=False)
+    updated_by: str | None = Field(None, validation_alias="updatedBy", exclude=True, repr=False)
+
+    # unused address/member detail fields
+    created_date: datetime | None = Field(None, validation_alias="createdDate", exclude=True, repr=False)
+    updated_date: datetime | None = Field(None, validation_alias="updatedDate", exclude=True, repr=False)
+
+    address_line1: str | None = Field(None, validation_alias="addressLine1", exclude=True, repr=False)
+    address_line2: str | None = Field(None, validation_alias="addressLine2", exclude=True, repr=False)
+    alternate_emails: None = Field(None, validation_alias="alternateEmails", exclude=True, repr=False)
+    cc_last4: str | None = Field(None, validation_alias="ccLast4", exclude=True, repr=False)
+    cc_type: str | None = Field(None, validation_alias="ccType", exclude=True, repr=False)
+    city: str | None = Field(None, exclude=True, repr=False)
+    home_phone: str | None = Field(None, validation_alias="homePhone", exclude=True, repr=False)
+    intro_neccessary: bool | None = Field(None, validation_alias="introNeccessary", exclude=True, repr=False)
+    is_deleted: bool | None = Field(None, validation_alias="isDeleted", exclude=True, repr=False)
+    is_member_verified: bool | None = Field(None, validation_alias="isMemberVerified", exclude=True, repr=False)
+    lead_prospect: bool | None = Field(None, validation_alias="leadProspect", exclude=True, repr=False)
+    max_hr: int | None = Field(
+        None, validation_alias="maxHr", exclude=True, repr=False, description="Also found in member_profile"
+    )
+    online_signup: None = Field(None, validation_alias="onlineSignup", exclude=True, repr=False)
+    phone_type: None = Field(None, validation_alias="phoneType", exclude=True, repr=False)
+    postal_code: str | None = Field(None, validation_alias="postalCode", exclude=True, repr=False)
+    state: str | None = Field(None, exclude=True, repr=False)
+    work_phone: str | None = Field(None, validation_alias="workPhone", exclude=True, repr=False)
+    year_imported: int | None = Field(None, validation_alias="yearImported", exclude=True, repr=False)
+
+    @field_validator("birth_day")
+    @classmethod
+    def validate_birth_day(cls, value: date | str | None, **_kwargs) -> date | None:
+        """Convert birth_day to a date object if it is in the format of YYYY-MM-DD."""
+        if value is None:
+            return value
+        if not isinstance(value, date):
+            return datetime.strptime(value, "%Y-%m-%d").date()
+        return value
+
+    def update_name(self, first_name: str | None = None, last_name: str | None = None) -> None:
+        """Update the name of the member.
+
+        Args:
+            first_name (str | None): The new first name of the member.
+            last_name (str | None): The new last name of the member.
+        """
+        self.raise_if_api_not_set()
+
+        updated_member = self._api.members.update_member_name(first_name, last_name)
+        self.first_name = updated_member.first_name
+        self.last_name = updated_member.last_name

otf_api/models/members/member_membership.py

@@ -0,0 +1,26 @@
+from datetime import datetime
+
+from pydantic import Field
+
+from otf_api.models.base import OtfItemBase
+
+
+class MemberMembership(OtfItemBase):
+    payment_date: datetime | None = Field(None, validation_alias="paymentDate")
+    active_date: datetime | None = Field(None, validation_alias="activeDate")
+    expiration_date: datetime | None = Field(None, validation_alias="expirationDate")
+    current: bool | None = None
+    count: int | None = None
+    remaining: int | None = None
+    name: str | None = None
+    updated_date: datetime | None = Field(None, validation_alias="updatedDate")
+    created_date: datetime | None = Field(None, validation_alias="createdDate")
+    is_deleted: bool | None = Field(None, validation_alias="isDeleted")
+
+    member_membership_id: int | None = Field(None, validation_alias="memberMembershipId", exclude=True, repr=False)
+    member_membership_uuid: str | None = Field(None, validation_alias="memberMembershipUUId", exclude=True, repr=False)
+    membership_id: int | None = Field(None, validation_alias="membershipId", exclude=True, repr=False)
+    member_id: int | None = Field(None, validation_alias="memberId", exclude=True, repr=False)
+    mbo_description_id: str | None = Field(None, validation_alias="mboDescriptionId", exclude=True, repr=False)
+    created_by: str | None = Field(None, validation_alias="createdBy", exclude=True, repr=False)
+    updated_by: str | None = Field(None, validation_alias="updatedBy", exclude=True, repr=False)

otf_api/models/members/member_purchases.py

@@ -0,0 +1,29 @@
+from datetime import datetime
+
+from pydantic import Field
+
+from otf_api.models.base import OtfItemBase
+from otf_api.models.studios import StudioDetail
+
+
+class MemberPurchase(OtfItemBase):
+    purchase_uuid: str = Field(..., validation_alias="memberPurchaseUUId")
+    name: str | None = None
+    price: str | None = None
+    purchase_date_time: datetime | None = Field(None, validation_alias="memberPurchaseDateTime")
+    purchase_type: str | None = Field(None, validation_alias="memberPurchaseType")
+    status: str | None = None
+    quantity: int | None = None
+    studio: StudioDetail = Field(..., exclude=True, repr=False)
+
+    member_fee_id: int | None = Field(None, validation_alias="memberFeeId", exclude=True, repr=False)
+    member_id: int | None = Field(..., validation_alias="memberId", exclude=True, repr=False)
+    member_membership_id: int | None = Field(None, validation_alias="memberMembershipId", exclude=True, repr=False)
+    member_purchase_id: int | None = Field(..., validation_alias="memberPurchaseId", exclude=True, repr=False)
+    member_service_id: int | None = Field(None, validation_alias="memberServiceId", exclude=True, repr=False)
+    pos_contract_id: int | None = Field(None, validation_alias="posContractId", exclude=True, repr=False)
+    pos_description_id: int | None = Field(None, validation_alias="posDescriptionId", exclude=True, repr=False)
+    pos_pmt_ref_no: int | None = Field(None, validation_alias="posPmtRefNo", exclude=True, repr=False)
+    pos_product_id: int | None = Field(..., validation_alias="posProductId", exclude=True, repr=False)
+    pos_sale_id: int | None = Field(..., validation_alias="posSaleId", exclude=True, repr=False)
+    studio_id: int | None = Field(..., validation_alias="studioId", exclude=True, repr=False)

otf_api/models/members/notifications.py

@@ -0,0 +1,17 @@
+from pydantic import Field
+
+from otf_api.models.base import OtfItemBase
+
+
+class SmsNotificationSettings(OtfItemBase):
+    is_promotional_sms_opt_in: bool | None = Field(None, validation_alias="isPromotionalSmsOptIn")
+    is_transactional_sms_opt_in: bool | None = Field(None, validation_alias="isTransactionalSmsOptIn")
+    is_promotional_phone_opt_in: bool | None = Field(None, validation_alias="isPromotionalPhoneOptIn")
+    is_transactional_phone_opt_in: bool | None = Field(None, validation_alias="isTransactionalPhoneOptIn")
+
+
+class EmailNotificationSettings(OtfItemBase):
+    is_system_email_opt_in: bool | None = Field(None, validation_alias="isSystemEmailOptIn")
+    is_promotional_email_opt_in: bool | None = Field(None, validation_alias="isPromotionalEmailOptIn")
+    is_transactional_email_opt_in: bool | None = Field(None, validation_alias="isTransactionalEmailOptIn")
+    email: str | None = None

otf_api/models/mixins.py

@@ -1,13 +1,58 @@
+import typing
+from typing import Any
+
 from pydantic import AliasChoices, Field, field_validator, model_validator
 
+if typing.TYPE_CHECKING:
+    from otf_api.api.api import Otf
+
+
+class ApiMixin:
+    """Mixin for models that require an API instance to be set.
+
+    This allows us to create model methods such as `cancel`, `book`, etc., that require an API instance to function.
+    The API instance is set using the `set_api` method, and it can be accessed via the `_api` attribute.
+    If the API instance is not set, calling methods that require it will raise a ValueError.
+    """
+
+    _api: "Otf" = None  # type: ignore[assignment]
+
+    def set_api(self, api: "Otf") -> None:
+        """Set the API instance for this model."""
+        self._api = api
+
+    @classmethod
+    def create(cls, **kwargs) -> typing.Self:
+        """Creates a new instance of the model with the given keyword arguments."""
+        api = kwargs.pop("api", None)
+        instance = cls(**kwargs)
+        if api is not None:
+            instance.set_api(api)
+        return instance
+
+    def raise_if_api_not_set(self) -> None:
+        """Raises an error if the API instance is not set."""
+        if self._api is None:
+            raise ValueError("API instance is not set. Use set_api() to set it before calling this method.")
+
 
 class PhoneLongitudeLatitudeMixin:
+    """Mixin for models that require phone number, latitude, and longitude fields.
+
+    This mixin exists to make it easier to handle the various names these fields can have in different APIs.
+    """
+
     phone_number: str | None = Field(None, validation_alias=AliasChoices("phone", "phoneNumber"))
     latitude: float | None = Field(None, validation_alias=AliasChoices("latitude"))
     longitude: float | None = Field(None, validation_alias=AliasChoices("longitude"))
 
 
 class AddressMixin:
+    """Mixin for models that require address fields.
+
+    This mixin exists to make it easier to handle the various names these fields can have in different APIs.
+    """
+
     address_line1: str | None = Field(
         None, validation_alias=AliasChoices("line1", "address1", "address", "physicalAddress")
     )
@@ -27,7 +72,8 @@ class AddressMixin:
 
     @model_validator(mode="before")
     @classmethod
-    def check_country(cls, values):
+    def validate_model(cls, values: Any) -> Any:  # noqa: ANN401
+        """Validates address fields and country format, handling specific cases."""
         if set(values.keys()) == set(
             ["phone", "latitude", "longitude", "address1", "address2", "city", "state", "postalCode"]
         ):
@@ -44,6 +90,7 @@ class AddressMixin:
     @field_validator("address_line1", "address_line2", "city", "postal_code", "state", "country")
     @classmethod
     def clean_strings(cls, value: str | None, **_kwargs) -> str | None:
+        """Clean strings by stripping whitespace and returning None if empty."""
         if value is None:
             return value
         value = value.strip()

otf_api/models/studios/__init__.py

@@ -0,0 +1,5 @@
+from .enums import StudioStatus
+from .studio_detail import StudioDetail, StudioLocation
+from .studio_services import StudioService
+
+__all__ = ["StudioDetail", "StudioLocation", "StudioService", "StudioStatus"]

otf_api/models/studios/enums.py

@@ -0,0 +1,11 @@
+from enum import StrEnum
+
+
+class StudioStatus(StrEnum):
+    OTHER = "OTHER"
+    ACTIVE = "Active"
+    INACTIVE = "Inactive"
+    COMING_SOON = "Coming Soon"
+    TEMP_CLOSED = "Temporarily Closed"
+    PERM_CLOSED = "Permanently Closed"
+    UNKNOWN = "Unknown"

otf_api/models/studios/studio_detail.py

@@ -0,0 +1,93 @@
+from datetime import datetime
+
+from pydantic import AliasChoices, AliasPath, Field
+
+from otf_api.models.base import OtfItemBase
+from otf_api.models.mixins import AddressMixin, ApiMixin
+
+from .enums import StudioStatus
+
+
+class StudioLocation(AddressMixin, OtfItemBase):
+    phone_number: str | None = Field(None, validation_alias=AliasChoices("phone", "phoneNumber"))
+    latitude: float | None = Field(None, validation_alias=AliasChoices("latitude"))
+    longitude: float | None = Field(None, validation_alias=AliasChoices("longitude"))
+
+    physical_region: str | None = Field(None, validation_alias="physicalRegion", exclude=True, repr=False)
+    physical_country_id: int | None = Field(None, validation_alias="physicalCountryId", exclude=True, repr=False)
+
+
+class StudioDetail(ApiMixin, OtfItemBase):
+    studio_uuid: str = Field(..., validation_alias="studioUUId", description="The OTF studio UUID")
+
+    contact_email: str | None = Field(None, validation_alias="contactEmail")
+    distance: float | None = Field(
+        None,
+        description="Distance from latitude and longitude provided to `search_studios_by_geo` method,\
+              NULL if that method was not used",
+        exclude=True,
+        repr=False,
+    )
+    location: StudioLocation = Field(..., validation_alias="studioLocation", default_factory=StudioLocation)  # type: ignore
+    name: str | None = Field(None, validation_alias="studioName")
+    status: StudioStatus | None = Field(
+        None, validation_alias="studioStatus", description="Active, Temporarily Closed, Coming Soon"
+    )
+    time_zone: str | None = Field(None, validation_alias="timeZone")
+
+    # flags
+    accepts_ach: bool | None = Field(None, validation_alias="acceptsAch", exclude=True, repr=False)
+    accepts_american_express: bool | None = Field(
+        None, validation_alias="acceptsAmericanExpress", exclude=True, repr=False
+    )
+    accepts_discover: bool | None = Field(None, validation_alias="acceptsDiscover", exclude=True, repr=False)
+    accepts_visa_master_card: bool | None = Field(
+        None, validation_alias="acceptsVisaMasterCard", exclude=True, repr=False
+    )
+    allows_cr_waitlist: bool | None = Field(None, validation_alias="allowsCrWaitlist", exclude=True, repr=False)
+    allows_dashboard_access: bool | None = Field(
+        None, validation_alias="allowsDashboardAccess", exclude=True, repr=False
+    )
+    is_crm: bool | None = Field(None, validation_alias=AliasPath("studioProfiles", "isCrm"), exclude=True, repr=False)
+    is_integrated: bool | None = Field(
+        None, validation_alias="isIntegrated", exclude=True, repr=False, description="Always 'True'"
+    )
+    is_mobile: bool | None = Field(None, validation_alias="isMobile", exclude=True, repr=False)
+    is_otbeat: bool | None = Field(None, validation_alias="isOtbeat", exclude=True, repr=False)
+    is_web: bool | None = Field(None, validation_alias=AliasPath("studioProfiles", "isWeb"), exclude=True, repr=False)
+    sms_package_enabled: bool | None = Field(None, validation_alias="smsPackageEnabled", exclude=True, repr=False)
+
+    # misc
+    studio_id: int | None = Field(
+        None, validation_alias="studioId", description="Not used by API", exclude=True, repr=False
+    )
+    mbo_studio_id: int | None = Field(
+        None, validation_alias="mboStudioId", exclude=True, repr=False, description="MindBody attr"
+    )
+    open_date: datetime | None = Field(None, validation_alias="openDate", exclude=True, repr=False)
+    pricing_level: str | None = Field(
+        None, validation_alias="pricingLevel", exclude=True, repr=False, description="Pro, Legacy, Accelerate, or empty"
+    )
+    re_open_date: datetime | None = Field(None, validation_alias="reOpenDate", exclude=True, repr=False)
+    studio_number: str | None = Field(None, validation_alias="studioNumber", exclude=True, repr=False)
+    studio_physical_location_id: int | None = Field(
+        None, validation_alias="studioPhysicalLocationId", exclude=True, repr=False
+    )
+    studio_token: str | None = Field(None, validation_alias="studioToken", exclude=True, repr=False)
+    studio_type_id: int | None = Field(None, validation_alias="studioTypeId", exclude=True, repr=False)
+
+    @classmethod
+    def create_empty_model(cls, studio_uuid: str) -> "StudioDetail":
+        """Create an empty model with the given studio_uuid."""
+        # pylance doesn't know that the rest of the fields default to None, so we use type: ignore
+        return StudioDetail(studioUUId=studio_uuid, studioName="Studio Not Found", studioStatus="Unknown")  # type: ignore
+
+    def add_to_favorites(self) -> None:
+        """Adds the studio to the user's favorites."""
+        self.raise_if_api_not_set()
+        self._api.studios.add_favorite_studio(self.studio_uuid)
+
+    def remove_from_favorites(self) -> None:
+        """Removes the studio from the user's favorites."""
+        self.raise_if_api_not_set()
+        self._api.studios.remove_favorite_studio(self.studio_uuid)

otf_api/models/studios/studio_services.py

@@ -0,0 +1,36 @@
+from datetime import datetime
+
+from pydantic import Field
+
+from otf_api.models.base import OtfItemBase
+from otf_api.models.studios import StudioDetail
+
+
+class StudioService(OtfItemBase):
+    studio: StudioDetail = Field(..., exclude=True, repr=False)
+    service_uuid: str = Field(..., validation_alias="serviceUUId")
+    name: str | None = None
+    price: str | None = None
+    qty: int | None = None
+    online_price: str | None = Field(None, validation_alias="onlinePrice")
+    tax_rate: str | None = Field(None, validation_alias="taxRate")
+    current: bool | None = None
+    is_deleted: bool | None = Field(None, validation_alias="isDeleted")
+    created_date: datetime | None = Field(None, validation_alias="createdDate")
+    updated_date: datetime | None = Field(None, validation_alias="updatedDate")
+
+    # unused fields
+
+    # ids
+    mbo_program_id: int | None = Field(None, validation_alias="mboProgramId", exclude=True, repr=False)
+    mbo_description_id: str | None = Field(None, validation_alias="mboDescriptionId", exclude=True, repr=False)
+    mbo_product_id: int | None = Field(None, validation_alias="mboProductId", exclude=True, repr=False)
+    service_id: int | None = Field(None, validation_alias="serviceId", exclude=True, repr=False)
+    studio_id: int | None = Field(None, validation_alias="studioId", exclude=True, repr=False)
+    created_by: str | None = Field(None, validation_alias="createdBy", exclude=True, repr=False)
+    updated_by: str | None = Field(None, validation_alias="updatedBy", exclude=True, repr=False)
+
+    # flags
+    is_web: bool | None = Field(None, validation_alias="isWeb", exclude=True, repr=False)
+    is_crm: bool | None = Field(None, validation_alias="isCrm", exclude=True, repr=False)
+    is_mobile: bool | None = Field(None, validation_alias="isMobile", exclude=True, repr=False)

otf_api/models/workouts/__init__.py

@@ -0,0 +1,31 @@
+from .body_composition_list import BodyCompositionData
+from .challenge_tracker_content import ChallengeTracker
+from .challenge_tracker_detail import FitnessBenchmark
+from .enums import ChallengeCategory, EquipmentType, StatsTime
+from .lifetime_stats import InStudioStatsData, OutStudioStatsData, StatsResponse, TimeStats
+from .out_of_studio_workout_history import OutOfStudioWorkoutHistory
+from .performance_summary import HeartRate, PerformanceSummary, Rower, Treadmill, ZoneTimeMinutes
+from .telemetry import Telemetry, TelemetryHistoryItem
+from .workout import Workout
+
+__all__ = [
+    "BodyCompositionData",
+    "ChallengeCategory",
+    "ChallengeTracker",
+    "EquipmentType",
+    "FitnessBenchmark",
+    "HeartRate",
+    "InStudioStatsData",
+    "OutOfStudioWorkoutHistory",
+    "OutStudioStatsData",
+    "PerformanceSummary",
+    "Rower",
+    "StatsResponse",
+    "StatsTime",
+    "Telemetry",
+    "TelemetryHistoryItem",
+    "TimeStats",
+    "Treadmill",
+    "Workout",
+    "ZoneTimeMinutes",
+]